虚拟币用到的非常哇塞的技术(Raft共识算法)解读-CSDN博客

本文链接：https://blog.csdn.net/zhangzhechun_03/article/details/147698334

python编程示例系列
 python编程示例系列二
 python的Web神器Streamlit
如何应聘高薪职位
 C#视觉应用开发问题系列
 c#串口应用开发问题系列
 microPython Python最小内核源码解析
 NI-motion运动控制c语言示例代码解析
在这里插入图片描述 # Raft共识算法详解

一、用途

Raft是一种用于分布式系统中的共识算法，主要解决了在分布式环境下多个节点如何就某一数据状态达成一致的问题。在虚拟币领域，共识算法是确保所有节点对交易记录达成一致的关键技术。Raft算法的主要特点是易于理解和实现，同时提供了与Paxos等算法相当的安全性和性能。

二、原理

Raft算法将共识问题分解为三个相对独立的子问题：

领导者选举（Leader Election）：当现有领导者失效时，选举新的领导者。
日志复制（Log Replication）：领导者接收客户端请求并将其作为日志条目复制到所有节点。
安全性（Safety）：如果任何节点已应用某个日志条目到其状态机，那么其他节点不会在同一位置应用不同的日志条目。

核心概念

节点状态：每个节点可以处于三种状态之一：领导者(Leader)、跟随者(Follower)、候选人(Candidate)。
任期号(Term)：Raft将时间划分为任意长度的任期，每个任期都有一个连续递增的编号。
心跳机制：Leader定期向所有Follower发送心跳消息，以维持其权威。
投票机制：Candidate请求其他节点投票，获得多数票者成为Leader。
日志条目：包含命令和任期号，用于状态机复制。

三、实现代码示例

下面是一个简化的Raft算法实现，使用Go语言：

package raft

import (
    "math/rand"
    "sync"
    "time"
)

// 节点状态枚举
const (
    Follower  = "Follower"
    Candidate = "Candidate"
    Leader    = "Leader"
)

// 日志条目结构
type LogEntry struct {
    Term    int         // 任期号
    Command interface{} // 命令内容
}

// RPC请求投票的参数
type RequestVoteArgs struct {
    Term         int // 候选人的任期号
    CandidateId  int // 请求选票的候选人ID
    LastLogIndex int // 候选人的最后日志条目的索引值
    LastLogTerm  int // 候选人最后日志条目的任期号
}

// RPC请求投票的响应
type RequestVoteReply struct {
    Term        int  // 当前任期号，用于候选人更新自己
    VoteGranted bool // true表示候选人赢得了选票
}

// RPC附加日志的参数
type AppendEntriesArgs struct {
    Term         int        // 领导人的任期号
    LeaderId     int        // 领导人ID
    PrevLogIndex int        // 新的日志条目紧随之前的索引值
    PrevLogTerm  int        // 前一个日志条目的任期号
    Entries      []LogEntry // 准备存储的日志条目
    LeaderCommit int        // 领导人已经提交的日志的索引值
}

// RPC附加日志的响应
type AppendEntriesReply struct {
    Term    int  // 当前任期号，用于领导人更新自己
    Success bool // true表示跟随者包含了匹配上PrevLogIndex和PrevLogTerm的日志条目
}

// Raft节点结构
type Raft struct {
    mu sync.Mutex // 锁，用于保护共享数据

    // 持久化状态
    currentTerm int        // 当前任期号
    votedFor    int        // 当前任期内投票给哪个候选人的ID，如果没有投票则为-1
    log         []LogEntry // 日志条目数组

    // 易失性状态
    commitIndex int // 已知的最大的已经被提交的日志条目的索引值
    lastApplied int // 最后被应用到状态机的日志条目索引值

    // 领导人特有的易失性状态
    nextIndex  []int // 对于每个服务器，需要发送给他的下一个日志条目的索引值
    matchIndex []int // 对于每个服务器，已经复制到该服务器的日志的最高索引值

    // 其他状态
    state       string    // 当前节点状态：Follower, Candidate, Leader
    leaderId    int       // 当前领导人ID
    nodeId      int       // 当前节点ID
    nodes       []int     // 集群中的所有节点ID
    electionTimer *time.Timer // 选举计时器
    heartbeatTimer *time.Timer // 心跳计时器
}

// 创建新的Raft节点
func NewRaft(nodeId int, nodes []int) *Raft {
    rf := &Raft{
        currentTerm: 0,
        votedFor:    -1,
        log:         make([]LogEntry, 1), // 索引0处放置一个空日志条目
        commitIndex: 0,
        lastApplied: 0,
        state:       Follower,
        leaderId:    -1,
        nodeId:      nodeId,
        nodes:       nodes,
        nextIndex:   make([]int, len(nodes)),
        matchIndex:  make([]int, len(nodes)),
    }

    // 初始化为跟随者状态
    rf.becomeFollower(0)
    
    return rf
}

// 转变为跟随者状态
func (rf *Raft) becomeFollower(term int) {
    rf.mu.Lock()
    defer rf.mu.Unlock()
    
    rf.state = Follower
    rf.currentTerm = term
    rf.votedFor = -1
    rf.leaderId = -1
    
    // 重置选举计时器
    rf.resetElectionTimer()
}

// 转变为候选人状态
func (rf *Raft) becomeCandidate() {
    rf.mu.Lock()
    defer rf.mu.Unlock()
    
    rf.state = Candidate
    rf.currentTerm++
    rf.votedFor = rf.nodeId
    
    // 重置选举计时器
    rf.resetElectionTimer()
    
    // 开始选举
    go rf.startElection()
}

// 转变为领导者状态
func (rf *Raft) becomeLeader() {
    rf.mu.Lock()
    defer rf.mu.Unlock()
    
    if rf.state != Candidate {
        return
    }
    
    rf.state = Leader
    rf.leaderId = rf.nodeId
    
    // 初始化领导人特有的状态
    lastLogIndex := len(rf.log) - 1
    for i := range rf.nextIndex {
        rf.nextIndex[i] = lastLogIndex + 1
        rf.matchIndex[i] = 0
    }
    
    // 停止选举计时器，开始心跳
    if rf.electionTimer != nil {
        rf.electionTimer.Stop()
    }
    rf.startHeartbeat()
}

// 重置选举计时器
func (rf *Raft) resetElectionTimer() {
    if rf.electionTimer != nil {
        rf.electionTimer.Stop()
    }
    
    // 随机化选举超时时间（150-300ms）
    electionTimeout := 150 + rand.Intn(150)
    rf.electionTimer = time.AfterFunc(time.Duration(electionTimeout)*time.Millisecond, func() {
        rf.becomeCandidate()
    })
}

// 开始领导者选举
func (rf *Raft) startElection() {
    rf.mu.Lock()
    
    // 准备请求投票参数
    args := RequestVoteArgs{
        Term:         rf.currentTerm,
        CandidateId:  rf.nodeId,
        LastLogIndex: len(rf.log) - 1,
        LastLogTerm:  rf.log[len(rf.log)-1].Term,
    }
    
    term := rf.currentTerm
    rf.mu.Unlock()
    
    // 统计投票
    votesReceived := 1 // 自己投给自己
    var votesMu sync.Mutex
    
    // 向其他节点请求投票
    for _, nodeId := range rf.nodes {
        if nodeId == rf.nodeId {
            continue
        }
        
        go func(nodeId int) {
            var reply RequestVoteReply
            // 这里应该是RPC调用，为了简化，我们假设直接调用
            ok := rf.sendRequestVote(nodeId, &args, &reply)
            
            if ok {
                rf.mu.Lock()
                defer rf.mu.Unlock()
                
                // 如果发现更高的任期，转为跟随者
                if reply.Term > rf.currentTerm {
                    rf.becomeFollower(reply.Term)
                    return
                }
                
                // 如果仍是候选人且在同一任期内
                if rf.state == Candidate && rf.currentTerm == term {
                    if reply.VoteGranted {
                        votesMu.Lock()
                        votesReceived++
                        // 如果获得多数票，成为领导者
                        if votesReceived > len(rf.nodes)/2 {
                            votesMu.Unlock()
                            rf.becomeLeader()
                            return
                        }
                        votesMu.Unlock()
                    }
                }
            }
        }(nodeId)
    }
}

// 发送请求投票RPC（模拟）
func (rf *Raft) sendRequestVote(nodeId int, args *RequestVoteArgs, reply *RequestVoteReply) bool {
    // 在实际实现中，这里应该是RPC调用
    // 为了简化示例，我们假设总是成功并随机返回结果
    reply.Term = args.Term
    reply.VoteGranted = rand.Intn(2) == 1
    return true
}

// 开始发送心跳
func (rf *Raft) startHeartbeat() {
    // 立即发送心跳
    rf.broadcastAppendEntries()
    
    // 设置定期心跳
    if rf.heartbeatTimer != nil {
        rf.heartbeatTimer.Stop()
    }
    rf.heartbeatTimer = time.AfterFunc(100*time.Millisecond, func() {
        rf.mu.Lock()
        defer rf.mu.Unlock()
        
        if rf.state == Leader {
            rf.startHeartbeat()
        }
    })
}

// 广播附加日志RPC（也用于心跳）
func (rf *Raft) broadcastAppendEntries() {
    rf.mu.Lock()
    defer rf.mu.Unlock()
    
    if rf.state != Leader {
        return
    }
    
    for _, nodeId := range rf.nodes {
        if nodeId == rf.nodeId {
            continue
        }
        
        // 准备参数
        prevLogIndex := rf.nextIndex[nodeId] - 1
        prevLogTerm := rf.log[prevLogIndex].Term
        entries := rf.log[rf.nextIndex[nodeId]:]
        
        args := AppendEntriesArgs{
            Term:         rf.currentTerm,
            LeaderId:     rf.nodeId,
            PrevLogIndex: prevLogIndex,
            PrevLogTerm:  prevLogTerm,
            Entries:      entries,
            LeaderCommit: rf.commitIndex,
        }
        
        go func(nodeId int, args AppendEntriesArgs) {
            var reply AppendEntriesReply
            ok := rf.sendAppendEntries(nodeId, &args, &reply)
            
            if ok {
                rf.mu.Lock()
                defer rf.mu.Unlock()
                
                // 如果发现更高的任期，转为跟随者
                if reply.Term > rf.currentTerm {
                    rf.becomeFollower(reply.Term)
                    return
                }
                
                // 如果仍是领导者且在同一任期内
                if rf.state == Leader && rf.currentTerm == args.Term {
                    if reply.Success {
                        // 更新nextIndex和matchIndex
                        rf.nextIndex[nodeId] = args.PrevLogIndex + len(args.Entries) + 1
                        rf.matchIndex[nodeId] = args.PrevLogIndex + len(args.Entries)
                        
                        // 尝试提交新的日志条目
                        rf.updateCommitIndex()
                    } else {
                        // 如果失败，减少nextIndex并重试
                        rf.nextIndex[nodeId] = max(1, rf.nextIndex[nodeId]-1)
                    }
                }
            }
        }(nodeId, args)
    }
}

// 发送附加日志RPC（模拟）
func (rf *Raft) sendAppendEntries(nodeId int, args *AppendEntriesArgs, reply *AppendEntriesReply) bool {
    // 在实际实现中，这里应该是RPC调用
    // 为了简化示例，我们假设总是成功并随机返回结果
    reply.Term = args.Term
    reply.Success = rand.Intn(2) == 1
    return true
}

// 更新commitIndex
func (rf *Raft) updateCommitIndex() {
    // 找出已经被大多数节点复制的最大日志索引
    for n := rf.commitIndex + 1; n < len(rf.log); n++ {
        if rf.log[n].Term == rf.currentTerm {
            // 计算有多少节点已经复制了这个日志条目
            count := 1 // 包括自己
            for _, nodeId := range rf.nodes {
                if nodeId != rf.nodeId && rf.matchIndex[nodeId] >= n {
                    count++
                }
            }
            
            // 如果大多数节点已复制，则提交
            if count > len(rf.nodes)/2 {
                rf.commitIndex = n
            }
        }
    }
    
    // 应用新提交的日志条目到状态机
    rf.applyCommittedEntries()
}

// 应用已提交的日志条目到状态机
func (rf *Raft) applyCommittedEntries() {
    for rf.lastApplied < rf.commitIndex {
        rf.lastApplied++
        // 在实际实现中，这里应该将命令应用到状态机
        // 例如：applyChannel <- ApplyMsg{CommandIndex: rf.lastApplied, Command: rf.log[rf.lastApplied].Command}
    }
}

// 辅助函数：返回两个整数中的较大值
func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}