目录

• 前言
• 一、引子
• 二、3A实现
  • 结构体设计
  • 每个节点应有的状态
  • 定义一些枚举常量
  • raft结构体
  • RPC 结构
  • raft节点初始化
  • 定时检测的 go 协程 ticker
  • 开始选举 startElection
  • 广播心跳
  • RequestVote 处理逻辑
  • AppendEntries 心跳逻辑
  • .8 节点是否被关闭，和关闭节点
  • 获取节点状态是否为 leader
• 三、测试和遇到的问题

  

  • 常见痛点与调试技巧
• 四、收获

前言

一、引子

2023 年之后Raft 被放到 lab3。lab2 实现一个简单的 KV 服务器，lab3 则分为 A、B、C、D 四个部分。分别对应领导选举、日志复制、持久化和快照。只要把论文通读三四遍，并结合 B 站视频或辅助文章，一般都能顺利完成。难度排行大概是 D> B> A> C，光看论文往往不够，需要动手调试。其实，

二、3A实现

结构体设计——先看测试函数。理清需求再动手实现

• TestInitialElection3A：

  • 在可靠网络且全部节点在线的情况下能否在一定时间内选出 Leader。
  • 验证 term 至少从 1 开始，而且在没有网络分区时保持稳定。说起来，

• TestReElection3A：

  • 断开当前 Leader 后其余节点能否重新选出新 Leader。其实，
  • 旧 Leader 恢复后必须转为 Follower。而不是抢占新 Leader。话说回来，
  • 当多数派失效时集群不应错误地产生 Leader；多数派恢复后应重新选出 Leader。
• • N 节点在频繁网络断连/重连的情况下始终保持“最多只有一个 Leader”，而且不会出现长时间无 Leader 的情况。
  • This test is most likely to expose random timeout bugs,deadlocks。lock leaks or Candidate not stepping down.

func TestInitialElection3A {
servers := ts := makeTest
defer ts.cleanup
tester.AnnotateTest
ts.Begin: initial election")
// is a leader elected?ts.checkOneLeader
// sleep a bit to avoid racing with followers learning of election,// n check that all peers agree on term.
time.Sleep
term1 := ts.checkTerms
if term1 < { // omitted for brevity
        ts.t.Fatalf
    }
    // does  leader+term stay  same if re is no network failure?
    time.Sleep
    term2 := ts.checkTerms
    if term1 != term2 {
        fmt.Printf
    }
    // re should still be a leader.
    ts.checkOneLeader
}
... // TestReElection3A and TestManyElections3A omitted for brevity

每个节点应有的状态：

定义一些枚举常量：

// HeartBeatTimeout 定义一个全局心跳超时时间
var HeartBeatTimeout = *time.Millisecond
// 固定超时时间枚举
const (
HeartbeatInterval = *time.Millisecond // 心跳间隔
ElectionTimeoutMin = *time.Millisecond // 选举超时下限
ElectionTimeoutMax = *time.Millisecond // 选举超时上限
RPCTimeout = *time.Millisecond // RPC 超时
)
// 枚举节点状态
type PeerState int
const (
Follower PeerState = iota // 追随者
Candidate // 候选者
Leader // 领导者
)
// 日志条目
type LogEntry struct {
Term int // 任期
Command interface{} // 命令
}

raft结构体

// A Go object implementing a single Raft peer.
type Raft struct {
mu sync.Mutex // 锁保护共享状态
peers *labrpc.ClientEnd // 所有节点的 RPC endpoint
persister *tester.Persister // 持久化对象
me int // 本节点在 peers 中的下标
state PeerState // 当前角色：Follower/Candidate/Leader
term int // 当前任期
votedFor int // 本任期已投票给谁
votenums int // 本轮已获得票数
logs LogEntry // 日志数组。下标0为占位符
commitIndex int // 已提交的日志索引
lastApplied int // 已应用到状态机的日志索引
// 以下仅对 Leader 有意义，但提前放置便于后续实验 B/C。nextIndex int // 对每个 follower 的下一个待发送日志索引
matchIndex int // 已复制到每个 follower 的最高索引
lastHeartBeatTime time.Time // 最近一次收到心跳时间
electionTimeout time.Duration// 当前随机选举超时时间
applyChan chan raftapi.ApplyMsg// 用于向状态机发送 Apply 消息
dead int32 // 是否被 Kill
applyCond *sync.Cond // 用于唤醒 applier goroutine
}

RPC 结构——既是选举也是心跳基础

*AppendEntries*: 在本阶段仅用于心跳；不过，字段 PrevLogIndex/PrevLogTerm/Entries/LeaderCommit 为后续实验 B 做准备。

// AppendEntries RPC 请求参数
type AppendEntriesArgs struct {
Term int // leader 任期
LeaderId int // leader ID
PrevLogIndex int // 紧邻新条目之前的最终一条日志索引
PrevLogTerm int // 对应任期
Entries LogEntry // 待追加的新条目
LeaderCommit int // leader 已提交的日志索引
}
// AppendEntries RPC 回复参数
type AppendEntriesReply struct {
Term int // 用于让 leader 更新自己的任期信息
Success bool// 当 follower 包含匹配的 PrevLog 条目时返回 true
}

*RequestVote*: 候选人发起投票请求，Follower 根据任期及日志新旧决定是否投票。

type RequestVoteArgs struct {
Term int // 候选人的任期
CandidateId int /* Candidate ID */
LastLogIndex int /* Candidate 最终一条日志索引 */
LastLogTerm int /* Candidate 最终一条日志任期 */
}
type RequestVoteReply struct {
Term int /* 当前任期，用于候选人更新 */
VoteGranted bool /* 是否同意投票 */
}

Raft 节点初始化 —— Make

func Make(peers *labrpc.ClientEnd,me int,persister *tester.Persister。applyCh chan raftapi.ApplyMsg) raftapi.Raft {
rf := &Raft{}
rf.peers = peers
rf.persister = persister
rf.me = me
rf.applyChan = applyCh
// 初始化基础状态和日志占位符
rf.state = Follower // 启动时为追随者
rf.term = 0 //
rf.votedFor = -1 //
rf.votenums = 0 //
rf.logs = LogEntry{{Term:0}} //
rf.commitIndex = 0 //
rf.lastApplied = 0 //
rf.nextIndex = make)
rf.matchIndex= make)
rf.lastHeartBeatTime = time.Now
rf.electionTimeout = rf.randElectionTimeout
// 从磁盘恢复持久化状态
rf.readPersist)
go rf.ticker // 启动周期检测协程
go rf.applier // 将已提交日志写入状态机
rand.Seed.UnixNano + int64)// 随机种子防止同步启动
return rf
}

随机选举超时时间生成函数

// 随机生成 区间内的超时时间。func randElectionTimeout time.Duration {
return time.Duration)) * time.Millisecond
}

定时检测协程 ticker —— 心跳 vs 超时发起选举

// ticker 每隔短暂时间检查自身角色并执行相应动作。func ticker {
for!rf.Killed {
time.Sleep // 检查频率可调节
rf.mu.Lock
curState := rf.state
if curState == Leader {
rf.mu.Unlock // 解锁后发送心跳避免死锁
rf.broadcastHeartbeat
continue //
循环等待下一次检查
}
elapsed := time.Since
timeout := rf.electionTimeout
rf.mu.Unlock
if elapsed>= timeout {
DPrintf
rf.startElection
}
}
}

开始选举 startElection —— Candidate → Leader 流程

// 发起一次完整的 Raft 投票过程。func startElection {
rf.mu.Lock
if rf.state == Leader { // 防止已是 leader 时误触发
rf.mu.Unlock
return
}
rf.state = Candidate //
rf.term++ //
curTerm := rf.term //
rf.votedFor = rf.me //
rf.votenums = 1 //
lastlogindex := len-1
lastlogterm := rf.logs.Term
rf.lastHeartBeatTime = time.Now
rf.electionTimeout = rf.randElectionTimeout
DPrintf
rf.mu.Unlock
for i := range rf.peers {
if i == rf.me { continue }
go func {
args := RequestVoteArgs{
从Term来看。curTerm,CandidateId: rf.me,LastLogIndex: lastlogindex,LastLogTerm: lastlogterm,}
var reply RequestVoteReply
ok := rf.sendRequestVote
if!ok { return }
rf.mu.Lock
defer rf.mu.Unlock
if reply.Term> curTerm { /* 收到更大任期 → 降为 Follower */
if reply.Term> rf.term {
rf.term = reply.Term
}
rf.state = Follower
rf.votedFor= -1
DPrintf
return
}
if reply.VoteGranted && rf.state == Candidate && args.Term == rf.term {
rf.votenums++
if rf.votenums> len/2 && rf.state == Candidate {
/* 成功当选 Leader */
DPrintf
rpcOldState:=rf.state
_=rpcOldState /* 防止未使用警告 */
再看rfsave，=rf.state /* 同上 */
_=rfsave
RFstate:=Leader /* 将 state 改成常量 */
_=RFstate
RFstate=Leader
rfsave=Leader
rfsave=Lead
rfsave=
# placeholder – removed duplicate lines due to editing artifact
...
...


...

} 

** 

Pain Point #1 – 锁泄漏导致 TestManyElections 卡死：A candidate 获得投票但未达到多数时没有及时释放锁。从解决办法来看，无论是否过半。都要在返回前执行 alertUnlock.

广播心跳 broadcastHeartbeat
// 当自己是 Leader 时向所有 follower 广播空心跳。func broadcastHeartbeat {
.rf.mu.Lock
if cf.State!= Leadere {
 . . .


if . . .{

} else{

if cf.State!= Leadere {
if cf.State!= Leadere{

if cf.State!= Leadere{


}else{
}

else {
else {

else{


...


此处仅发送空切片作为心跳。

RequestVote RPC Handler – 投票决策关键点 

// 请求投票接口，实现 Raft 中对候选人的严格投票规则。说起来，func RequestVote(args *RequestVoteArgs。reply *RequestVoteReply) {


.rf.mu.Lock;defer .Unlock;怎么说呢，

DPrintf(" RequestVote from candidate=% d args.Term=% d my.Term=% d"。
rp.Me,args.CandidateID,args.Term,Rf.Term );

// 如果候选人任期小于自己，则直接拒绝。If args. Term 

// 任期相等或更大。需要做以下两件事：
// - 若比自己更大，则更新自己的 Term 并重置投票。// - 将自身转为 Follower，以免与新的领导者冲突。If args.TERm> R.F.TERm{
RF.TERM=args.TERm;RF.VOTEDFOR=-ONE;}
RF.STATE=FOLLOWER;

// 判断候选人日志是否“至少跟我一样新”。若满足条件且自己尚未投票或已投给该候選人，则同意投票。IsUptodate:=RF.isloguptodate;If || RF.VOTEDFOR==args.CANDIDATEID)&& IsUptodate{
RF.VOTEDFOR=args.CANDIDATEID;reply.VOTEGRANTED=true;RF.LASTHEARTBEATTIME=time.now;怎么说呢，DPRINTF;不过，} Else{
reply.VOTEGRANTED=false;Dprintf，}
reply.TERM=Rf.term;}
...


Pain Point #2 – 未对 state 加锁导致竞态：The very first line `if args.Term 

判断候选人日志是否足够新的辅助函数 

func isloguptodatebool{
MyLastIdx:=len-ONE;MyLastTERM:=RF.LOGS.TERM;If args.LastLOGTERM> MyLastTERM{return TRUE};按理说，If args.LastLOGTERM =MyLastIDX;}



append="" <="" entries="" h5="" style="MARGIN-TOP" term="" –="" 与="" 心="" 简化版，仅检查="" 跳刷新="" 跳逻辑="">


FUNC APPENDE nTRIES{
RF.MU.LOCK;DEFER RF.MU.UNLOCK；DPRINTF (" APPENDENTRIES FROM L% D TERM% D MY TER M% D STATE% D "。R.FME,ARGS.LEADERID,ARGSTERM,RFTERRM,RFS t ate )；IF ARGSTERMTERRM {/* Reject / REPLY.SUCCESS＝FALSE;REPLY_TERM＝RF_TERRM;RETURN }，RFLASTHEARTBEATTIME＝TIME.NOW；IF ARGS_TERM> RF_TER M || RF_STATE==CANDIDATE {/ step down */ };REPLY.SUCCESS＝TRUE;REPLYTerm＝RFTERRM;}






节点关闭 与 KILL 检测 
FUNCKILL{ ATOMIC.STOREINT32};FUNCKILLEDBOOL{ Z:= ATOMIC.LOADINT32;RETURN Z== ONE }

获取当前是否是 LEADER

FUNC*GETSTATE{ VAR TERM INT;VAR ISLEADER BOOL;RF.MU.LOCK，TERM=RF_TERRM;ISLEADER=，RF.MU.UNLOCK;按理说，RETURN TERM。ISLEADER }

如有错误欢迎指正~ 🎉️️️️️️️️️️️️‍♀️‍♂️‍♀️‍♂️‍♀️‍♂︎︎︎︎︎︎︎︎︎︎⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡🧠🧠🧠🧠🧠🧠🧠🧠 🐱🐱🐱🐱🐱🐱🐱🐱 🐾 🐾 🐾 🐾 🐾 🚀🚀🚀