茫茫雪原上,一支登山队散落在五处营地,对讲机里杂音不断。有人想冲顶,有人要下撤,补给还出了状况——如果没人拍板,队伍很快就会四分五裂。他们需要一位领队:负责看地图、分任务、定步调,在关键时刻做出唯一决策。可领队可能掉进冰缝,对讲机可能失联,甚至两个营地同时喊出“我是领队”。怎么选领队?选出来如何服众?领队失联了怎么办?这正是分布式系统中最经典的问题——Leader 选举。本文用登山队的视角,带你理解为什么需要 Leader、Bully 与 Raft 两种选举算法如何工作、任期与投票怎样防止双主、以及故障后如何重新选出领队。

岗位关联

学会 Leader 选举,等于拿到了理解 etcd、ZooKeeper、Kubernetes 高可用设计的钥匙。对后端工程师而言,这是排查分布式故障、设计高可用系统的必备底层功。

目录
  1. 可视化演示
  2. 一、选举的必要性
  3. 二、Leader 的职责
  4. 三、Bully 算法
  5. 四、Raft 选举机制
  6. 五、任期与投票
  7. 六、脑裂防护
  8. 七、可用性影响
  9. 八、故障恢复
  10. AI 应用场景
  11. Python 演示
  12. 常见误区
  13. 面试题

可视化演示

展示Bully集中式选举、Ring环式选举及Raft投票选举三种算法的节点通信与Leader选出的完整过程。

本节配有交互动效(进入视口后自动加载,约 3KB)。

Bully集中式选举 选举消息 新Leader Leader=max(ID) 发现Leader失效后向高ID节点发送选举消息最高存活ID成为新Leader

一、选举的必要性

登山队走到岔路口,十个队员有十种想法:体力好的想冲顶,经验少的想下撤,炊事员只关心补给。如果每个人各走各的,队伍会在雪坡上散成一片,谁也没法活着下山。这时必须有一个领队拍板定方向。分布式系统也一样,多个服务器节点如同一群队员,客户端同时发来写请求时,如果每个节点各自为政,同一个数据可能被改出好几个版本——就像两个人同时握着地图往不同方向走,谁都说自己对。

解决办法是让其中一个节点当 Leader(主节点),所有写请求都先进它这里,由它统一排序、统一决策。在 etcd、Kafka、ZooKeeper 这样的系统中,Leader 是共识机制的“代言人”:客户端把写请求交给 Leader,Leader 将操作记成日志,再复制给其他节点。只有集群里大多数节点确认,这条日志才算正式生效。这也引出了分布式系统最核心的一个概念——多数派(Quorum)。

登山队遇到岔路时,不需要所有人一致同意才行动——“大多数队员点头”就足够。因为两个多数派必然有交集,这套规则从根本上防止队伍分裂成两股力量各走一边。

Quorum=⌊N2⌋+1\text{Quorum} = \left\lfloor \frac{N}{2} \right\rfloor + 1
多数派门槛公式:N 个节点的集群,必须超过一半节点同意才算数。3 节点集群需要 2 票,5 节点集群需要 3 票。
  1. N 的含义N 代表集群中参与投票的总节点数,例如 3 个节点时 N=3。
    NN
  2. 取下整的括号对 N/2 做向下取整,偶数节点时不会出现“半个节点”。
    ⌊N2⌋\left\lfloor \frac{N}{2} \right\rfloor
  3. 加一得到严格多数保证任何两个多数派集合之间至少有一个公共节点,避免“两边各占一半”扯不清。
    ⌊N2⌋+1\left\lfloor \frac{N}{2} \right\rfloor + 1

二、Leader 的职责

领队不是光喊口号的人。他手里有三件事:看地图定路线(定方案)、给队员派活(分配任务)、每隔几分钟用对讲机报平安(让大家确认他还活着)。少一件,队伍都会出乱子。分布式系统里的 Leader 也是如此,它的职责可以归纳为三条:承接写请求、复制日志、发送心跳。

首先,Leader 是唯一接收客户端写请求的节点。它把并发写操作排成一条有序的日志,就像领队把今天的任务按优先级写在日志本上。其次,Leader 要把这条日志复制给所有 Follower(跟从者,即集群中的普通节点),只有大多数 Follower 确认后,日志才算“提交”(committed),客户端才会收到成功响应——这是数据不丢的保证。最后,Leader 周期性地向 Follower 发送心跳(Heartbeat),等于对讲机里那句“一切正常,继续按计划走”,防止 Follower 误以为领队失联而发起新选举。

登山队的重要决定必须“大多数人收到并确认”才作数。领队说“改走 C 线”,如果只有他自己知道,那不算数;至少两个以上小队长回话确认,全队才会真正转向。

committed  ⟺  count(ack)≥⌊N2⌋+1\text{committed} \iff \text{count(ack)} \ge \left\lfloor \frac{N}{2} \right\rfloor + 1
日志提交通俗说:Leader 发下去的任务,必须收到超过半数队员的“收到”回执,才算真正敲定。只回执给领队自己不作数。
  1. count(ack) 的含义count(ack) 是 Leader 收集到的 Follower 成功确认(acknowledge)的数量。
    count(ack)\text{count(ack)}
  2. 与多数派门槛比较确认数量必须达到 N 个节点的多数派门槛,例如 3 节点集群要收到 2 个确认。
    ≥⌊N2⌋+1\ge \left\lfloor \frac{N}{2} \right\rfloor + 1
  3. 提交的判定结果只有满足上式的日志条目才被标记为已提交(committed),才能对外回复客户端。
    committed  ⟺  …\text{committed} \iff \dots

三、Bully 算法

老派登山队的规矩很简单:谁装备最好、资历最深,谁就是老大。队员发现领队失联后,轮值的人不会谦虚,而是先扯着嗓子问一句:“有没有编号比我大的兄弟在?”如果有人应声,他就退一步,让更厉害的人来当;如果没人应,他就自己上。这就是 Bully 算法(霸道者算法)的直觉。

Bully 算法用节点 ID 决定优先级,ID 越大优先级越高。流程如下:某个节点 P 发现 Leader 失联,向所有 ID 比它大的节点发送竞选消息;如果有节点响应,P 就把竞选权让给响应者,自己退回待命;如果没人响应,P 直接当选。响应者会继续向更大 ID 的节点发起竞选,直到最大的存活节点胜出,并向全网广播“我是新 Leader”。整个过程像击鼓传花,花永远向“更大编号”的方向传,直到传不动为止。

Bully 的好处是规则简单、一锤定音;坏处是“资历最大的人一旦倒下,剩下的人又要重新比一轮”。就像队里最强壮的老队员掉进冰缝,其他队员又得争论“现在谁最厉害”,效率不高但至少不会乱。

winner=max⁡{i∣i∈alive}\text{winner} = \max\{i \mid i \in \text{alive}\}
谁能当选?所有活着的节点里 ID 最大的那个。和“谁力气大谁领队”是同一个逻辑。
  1. alive 集合alive 表示当前确认存活的节点编号集合,宕机的节点被排除在外。
    alive\text{alive}
  2. 取最大值max 运算从集合中挑出编号最大的节点。
    max⁡{i∣i∈alive}\max\{i \mid i \in \text{alive}\}
  3. winner 即为结果获胜者就是集合中的最大值节点,它将在广播确认后成为新 Leader。
    winner=max⁡{⋅}\text{winner} = \max\{\cdot\}

四、Raft 选举机制

现代登山队换了一套玩法:不拼资历,人人胸前挂一个随机闹钟。闹钟先响的人站出来说“我来带队”,其他队员如果确实没收到领队心跳,就投他一票。哪个候选人拿到多数票,就当领队。这个方法来自 Raft 共识算法,是当今分布式系统最流行的选举机制。

Raft 把节点分成三种角色:Follower(群众)、Candidate(候选人)、Leader(当权者)。选举过程是这样的:Follower 维护一个随机超时(论文推荐 150ms 到 300ms 之间随机);如果超时且没收到 Leader 心跳,它就把自己变成 Candidate,把自己的任期加一,先投自己一票,然后向所有节点发送“请求投票”(RequestVote)消息。其他节点在同一个任期内只能投一票,先到先得。Candidate 收到超过半数节点的赞成票后,立即转正为 Leader,开始周期性发送心跳。

随机闹钟让队员们几乎不会同时醒来抢着带队;万一真有两个同时响,票数不够就再等下一轮。随机性会在下一轮让某个人更早喊出口,最终自然收敛出一个领队。

Ttimeout=150+rand(0,150) msT_{\text{timeout}} = 150 + \text{rand}(0, 150)\ \text{ms}
随机超时:每个人闹钟的响铃时间都不一样,避免一窝蜂同时抢着当候选人导致票数分散。
  1. 150ms 基础值超时的最短时间下界,保证 Leader 的正常心跳有时间送达。
    150150
  2. 随机扰动项rand(0, 150) 生成 0 到 150 之间的随机毫秒数,让不同节点错开触发时机。
    rand(0,150)\text{rand}(0, 150)
  3. 总和超时时间基础值加随机扰动,每个节点拿到不同的超时,从而大概率只有一个人先“响铃”。
    150+rand(0,150) ms150 + \text{rand}(0, 150)\ \text{ms}

五、任期与投票

每次选举都会产生一个“第几任领队”。新领队上任前,会把对讲机里的届数加一,并大声报号:“我是第 5 任领队。”如果有人拿着更大的届数喊话,所有人都要听他的——哪怕他是刚从另一座营地上来的。这个“届数”在 Raft 里叫作任期(term)。

Raft 用任期作为逻辑时钟,解决“谁说了算”的争议。选举发起时,Candidate 把自己的任期加一,带着新的任期号去拉票;每个节点在同一个任期内只能投一票,先到先得;一旦收到更高任期的消息,节点立即更新自己的任期,并主动降级为 Follower。这套机制有两个关键效果:第一,旧 Leader 从网络分区恢复后,发现新 Leader 的任期比自己大,只能乖乖让位;第二,同一任期内最多只有一个节点能凑够多数派选票,从根本上堵死了“双主”的可能。

任期号就像登山队的“届数”,谁拿出更大的届数谁有资格指挥。老领队回来后发现队里已经是“第 5 任”当家,自然知道该退居二线当普通队员。

termnew=max⁡(termcur,termpeer+1)\text{term}_{\text{new}} = \max\left(\text{term}_{\text{cur}}, \text{term}_{\text{peer}} + 1\right)
任期更新的规则是“只认更大的数”:无论听到哪个任期号,只要比自己大,就立刻跟上并服从那个任期下的 Leader。
  1. 当前任期term_cur 是节点本地保存的任期编号,记录自己见过的最大任期。
    termcur\text{term}_{\text{cur}}
  2. 消息携带的任期加一term_peer + 1 表示如果对方任期更大,自己应当跟进到那个任期。
    termpeer+1\text{term}_{\text{peer}} + 1
  3. 取两者最大值max 运算保证任期号单调递增、永不回退。
    max⁡(termcur,termpeer+1)\max\left(\text{term}_{\text{cur}}, \text{term}_{\text{peer}} + 1\right)

六、脑裂防护

暴风雪过后,两个营地对讲机彻底失联。左营地 3 个人自己选了个领队,右营地 2 个人也选了个领队。两边都觉得“我是正统”,一个往北走,一个往南走——登山队分裂了。这就是分布式系统中最危险的故障:脑裂(Split-Brain)。登山队立下规矩:只有人数超过一半的营地选出的领队,全队才认。

Raft 解决脑裂的办法是“多数派仲裁”。一个网络分区必须收集到超过半数节点的选票,才能选出合法 Leader;没有达到多数派的少数派分区,永远选不出有效 Leader,只能拒绝写入、保持只读。举一个经典例子:5 节点集群被切成 3+2 两个分区。3 节点的分区能凑够 3 票(达到全局多数 3),可以正常选主;2 节点的分区最多只有 2 票,永远差一票,无法产生 Leader。这样,无论网络怎么切,最多只有一个分区拥有合法的 Leader。

登山队的规矩是“没有一半以上的人认可,谁都不是领队”。右营地只有两个人,就算他们自己选了个领队,全队也不认——这就是多数派机制对脑裂最朴素的防御。

valid_leader  ⟺  np≥⌊N2⌋+1\text{valid\_leader} \iff n_p \ge \left\lfloor \frac{N}{2} \right\rfloor + 1
少数派分区选出的“领队”是无效的,因为它的票数达不到全局多数派门槛。
  1. n_p 的含义n_p 表示某个网络分区内实际包含的节点数量。
    npn_p
  2. 与全局多数门槛比较分区内节点数必须大于等于全局多数派门槛。
    ≥⌊N2⌋+1\ge \left\lfloor \frac{N}{2} \right\rfloor + 1
  3. 合法 Leader 的判定只有满足该不等式的分区产出的 Leader 才被集群接受。
    valid_leader  ⟺  np≥…\text{valid\_leader} \iff n_p \ge \dots

七、可用性影响

领队掉进冰缝的瞬间,队伍不会立刻乱,但会陷入一段“群龙无首”的等待:大家先停下来等待确认,再重新投票选新领队。这段等待时间越短,队伍损失越小。分布式系统中,这段不可写的时间窗口叫作“无主窗口期”,直接决定了系统的可用性。

Leader 宕机到新 Leader 上任的时间由两部分构成:故障检测时间(等心跳超时)+ 选举时间(投票、统计、日志同步)。Raft 中,心跳越频繁,故障发现越快,但网络开销越大;选举超时越短,恢复越快,但容易因 Leader 正常抖动而频繁切主。实际部署时,etcd 通过调节 heartbeat-tick 和 election-tick 两个参数来权衡:心跳间隔短则反应快,选举超时设置为心跳间隔的 10 倍左右以避免抖动误伤。

登山队在“等待确认”和“快速投票”之间找平衡:等太久队伍僵住,反应太快又容易误判。可用性设计的本质,就是在反应快和反应准之间小心地走钢丝。

Tunavailable=Tdetect+TelectT_{\text{unavailable}} = T_{\text{detect}} + T_{\text{elect}}
不可用时间 = 发现故障的时间 + 完成选举的时间。想缩短总时间,就得两头同时优化。
  1. 故障检测时间T_detect 是从 Leader 真正宕机到 Follower 确认它失联所经过的时间,主要取决于心跳超时设置。
    TdetectT_{\text{detect}}
  2. 选举时间T_elect 是从第一个节点发起选举到新 Leader 上任并开始服务的时间,包括拉票、计票、任期确认。
    TelectT_{\text{elect}}
  3. 二者之和T_unavailable 是系统无法处理写请求的总时长,也就是不可用窗口。
    Tdetect+TelectT_{\text{detect}} + T_{\text{elect}}

八、故障恢复

新领队上任的第一件事,不是大喊“听我的”,而是拿起老领队的登山日志逐页核对:自己走到哪了,每个队员在哪,下一步该往哪走。如果有人落后几页,他要先把记录补齐再出发。而老领队恢复通信后,看到新领队的届数更大,也会低头认账,安静地回到队伍里当普通队员。

这套恢复流程对应 Raft 的日志同步机制。新 Leader 在上任后不立即接收旧日志的“指挥权”,而是通过心跳消息里携带的上一条日志索引(prevLogIndex)和任期号(prevLogTerm)与 Follower 逐一比对。只有索引和任期都匹配,Follower 才接受 Leader 后续的日志条目;如果不匹配,Leader 就回退到更早的日志继续比对,直到双方完全对齐。与此同时,旧 Leader 回归时会发现自己任期落后,自动降级为 Follower,并接受新 Leader 的日志覆盖——它任期内未提交的日志会被安全地丢弃。

每次换领队都不是从零开始——新领队必须沿着旧笔记继续写,老领队回来也接受现实。队伍的“共同记忆”(日志)就这样在一次次交接中被小心翼翼地延续下来,没有断层,没有错乱。

log_matches  ⟺  termprev=termcur∧indexprev=indexcur\text{log\_matches} \iff term_{\text{prev}} = term_{\text{cur}} \wedge index_{\text{prev}} = index_{\text{cur}}
日志对齐的校验条件:新 Leader 给出的上一条日志,任期号和索引号都必须与 Follower 的一致,后面的日志才会被接受。
  1. 上一条日志的任期term_prev 是 Leader 声称的“上一条日志所在任期”,用于校验日志是否完整连续。
    termprevterm_{\text{prev}}
  2. 上一条日志的索引index_prev 是那条日志的位置编号,两个条件要同时满足。
    indexprevindex_{\text{prev}}
  3. 与本地记录比对两者都与当前节点记录的 term_cur 和 index_cur 相等时,日志匹配成立,才继续追加新日志。
    termprev=termcur∧indexprev=indexcurterm_{\text{prev}} = term_{\text{cur}} \wedge index_{\text{prev}} = index_{\text{cur}}

AI 应用场景

场景一:etcd 与 Kubernetes 的高可用选主

阶段:系统架构设计

解决的问题:Kubernetes 集群有多个 API Server 节点,它们同时读写集群配置时会产生冲突。etcd 作为 K8s 的配置存储,内置了 Raft 选举机制:所有写请求必须经过唯一的 Leader 写入,其他节点只能跟从,从根源上避免配置版本分裂。

具体案例:一次生产环境中,某 K8s 集群的 5 节点 etcd 经历网络抖动,主节点被短暂隔离。剩余 4 个节点检测到心跳超时后自动发起选举,约 3 秒内选出新 Leader,API Server 短暂报错后自动恢复,集群配置没有出现任何不一致。

场景二:MongoDB 副本集自动切换

阶段:数据层高可用设计

解决的问题:数据库主节点宕机时,如果靠人工切换主库,业务会长时间中断。MongoDB 副本集使用类 Raft 的选举协议:主节点失联后,Secondary(从节点)通过投票选出新主库,驱动自动重连,把不可用时间压缩到秒级。

具体案例:某业务使用 3 节点 MongoDB 副本集,主库所在物理机意外断电。两个从节点在约 10 秒内完成心跳超时检测和选举,新主库自动上任,应用层通过连接串的 multiple host 配置自动切换,用户几乎无感知。

场景三:ZooKeeper 中的分布式锁仲裁

阶段:分布式协调服务

解决的问题:多个服务同时抢分布式锁时,需要一个权威节点统一仲裁。ZooKeeper 集群通过 Leader 选举选出协调者,所有锁的创建与释放都由 Leader 处理的会话顺序决定,保证锁唯一。

具体案例:某微服务系统中,库存扣减任务分布在不同机器上,利用 ZooKeeper 临时节点实现分布式锁。ZooKeeper Leader 负责给锁请求排序,避免超卖;当 Leader 节点故障时,集群自动选举新 Leader,锁服务不中断。

Python 演示

python50 行
import random  class RaftNode:    """一个模拟的 Raft 节点"""     def __init__(self, node_id):        self.node_id = node_id        self.role = "follower"        self.term = 0        self.vote_granted = set()     def election_timeout(self):        # 随机超时 150-300ms,模拟闹钟        return random.randint(150, 300) / 1000  def run_election(nodes, start_index, global_quorum):    candidate = nodes[start_index]    candidate.role = "candidate"    candidate.term += 1    candidate.vote_granted = {candidate.node_id}    for other in nodes:        if other.node_id != candidate.node_id:            other.term = candidate.term            candidate.vote_granted.add(other.node_id)    if len(candidate.vote_granted) >= global_quorum:        candidate.role = "leader"        return candidate    return None  def simulate_network_partition():    # 模拟 5 节点网络分区:左 3 右 2    left = [RaftNode(i) for i in range(3)]    right = [RaftNode(i) for i in range(3, 5)]    global_quorum = 5 // 2 + 1     leader_left = run_election(left, 0, global_quorum)    leader_right = run_election(right, 0, global_quorum)     print(f"左分区(3 个节点)选举:节点 {leader_left.node_id} 获 3 票,达到多数派 {global_quorum},当选 Leader。")    if leader_right:        print(f"右分区(2 个节点)选举:节点 {leader_right.node_id} 当选(异常情况)。")    else:        print("右分区(2 个节点)选举:仅 2 票不足 3 票,无法产生 Leader,脑裂被阻止。")  if __name__ == "__main__":    simulate_network_partition()
目的:用 Python 模拟 Raft 选举中的多数派仲裁,直观展示“5 节点集群被切成 3+2 后,只有 3 节点分区能选出 Leader,2 节点分区因票数不足而无法选主”,从而验证脑裂防护机制。
  1. candidate.vote_granted = {candidate.node_id}候选者先投自己一票,这是 Raft 中“先到先得”的第一步。
  2. candidate.term += 1发起选举前任期加一,确保自己的任期号比旧 Leader 新。
  3. for other in nodes:向分区内所有节点拉票,模拟广播 RequestVote 消息。
  4. if len(candidate.vote_granted) >= global_quorum:核心判定:赞成票必须达到全局多数派门槛,差一票都不行。
  5. global_quorum = 5 // 2 + 15 节点集群的多数派门槛是 3,这正是“过半才有效”的量化。
  6. leader_left = run_election(left, 0, global_quorum)左分区 3 个节点能凑够 3 票,选举成功。
  7. leader_right = run_election(right, 0, global_quorum)右分区只有 2 个节点,最多 2 票,选举必然失败。

常见误区

误区“选 Leader 难道不是一次性的吗?选出之后就固定了,不用再操心了吧?”

正解完全不是。Leader 可能崩溃、网络分区、进程 GC 停顿导致失联,任何时刻都可能失去 Leader 身份。系统通过心跳和任期不断确认现任 Leader 是否有效,一旦失联就自动进入新一轮选举。这也解释了为什么“故障恢复”是不可或缺的机制——选 Leader 不是一锤子买卖,而是持续保卫的过程。

为何常见:人们习惯“选一次管一届”的人类社会直觉,忽略了分布式系统中节点随时可能故障的残酷现实。

误区“系统必须保证绝对不出现两个 Leader,如果出现了就是设计缺陷。”

正解由于网络延迟和分区,分布式系统无法在“同一瞬间”让所有节点达成无歧义认知,短暂出现两个 Leader 是可能的。Raft 的应对思路是:任期加多数派投票让“假 Leader”无法被多数派确认,它任期内的写入不会被提交,最终被高任期压制。目标不是“物理上不可能出现”,而是“出现了也无害,且最终收敛到单主”。

为何常见:从单机编程的互斥模型迁移到分布式模型,总以为必须用“锁”彻底禁止,却忘了分布式系统没有全局时钟。

误区“把选举超时调到极致短,让系统秒级恢复,不是越短越好吗?”

正解超时太短会导致频繁选举:Leader 只是响应慢了一点,Follower 就耐不住性子发起投票,集群反复切主,可用性反而更差。Raft 选择 150-300ms 的随机超时,并建议选举超时是心跳间隔的 10 倍左右,就是在“快速恢复”和“避免抖动切主”之间取平衡。盲目调短超时是生产环境常见的事故根源。

为何常见:直观地追求“越快越好”,忽略了切换本身有代价——每次切主都要暂停写入、对齐日志。

误区“节点少,凑多数派更容易,选举更快,所以集群节点越少越好。”

正解选举速度只是权衡之一。3 节点集群最多容忍 1 个节点故障,5 节点集群可以容忍 2 个。生产环境用 5 节点是为了在冗余度、选举速度和网络开销之间取得平衡,而不是追求“最快选出 Leader”。节点多一票,就多一份安全;节点太少,一次故障就可能让系统失去多数派,彻底不可用。

为何常见:只看到“人少好办事”的直觉,没有意识到容错能力才是分布式系统的生命线。

面试题

Q1. Raft 中 Follower 变为 Candidate 的触发条件是什么?

单选题 · easy

  • A.持续收到 Leader 心跳
  • B.超时未收到 Leader 心跳← 正确答案
  • C.收到客户端写请求
  • D.发现自身 ID 最大

答案:B。Follower 只有在选举超时且没收到 Leader 心跳时才会变成 Candidate,就像队员听到对讲机里长时间没有领队的声音才会站出来。A 是维持现状的条件,C 是正常服务流程,D 是 Bully 算法的逻辑,都不是 Raft 的触发条件。

Q2. 关于 Bully 算法的描述,正确的有哪些?

多选题 · easy

  • A.节点按编号决高下← 正确答案
  • B.最大编号存活者当选← 正确答案
  • C.选举过程依赖多数派投票
  • D.编号越小越优先

答案:AB。Bully 算法的核心是“编号大的节点优先级高”,最终 ID 最大的存活节点当选,A 和 B 正确。C 是 Raft 的特点,Bully 不依赖多数派投票。D 方向完全反了,编号小反而最吃亏。

Q3. 在同一个任期内,一个 Raft 节点最多能给几个候选者投票?

单选题 · mid

  • A.零个,不可投票
  • B.一个,先到先得← 正确答案
  • C.两个,可重复投
  • D.任意多个都行

答案:B。Raft 规定每个节点在同一任期内只能投一张票,先到先得。这是防止双主的关键:即使两个候选者同时拉票,每个节点也只能支持其中一个。就像每人手里只有一张选票,不能又投张三又投李四。

Q4. 在 5 节点 Raft 集群中,选举 Leader 至少需要几张赞成票?

单选题 · mid

  • A.一张赞成票即可
  • B.两张赞成票即可
  • C.三张赞成票即可← 正确答案
  • D.四张赞成票即可

答案:C。根据多数派公式 Quorum = 5 // 2 + 1 = 3,至少需要 3 张赞成票。1 票、2 票都不到半数,4 票虽然可行但并非“至少”。这正是登山队“过半认可才认领队”的量化体现。

Q5. 网络分区场景下,防止脑裂的关键机制是什么?

单选题 · mid

  • A.让每个分区各自选举
  • B.坚持多数派仲裁原则← 正确答案
  • C.依靠节点编号排序
  • D.只要心跳频率加倍

答案:B。多数派仲裁原则保证只有节点数达到多数派的分区才能选出有效 Leader,少数派分区无法产生 Leader。A 恰恰是产生脑裂的原因而非解决办法,C 是 Bully 的思路,D 与防脑裂无关。就像登山队规定“不到半数营地,谁选领队都不认”。

Q6. 旧 Leader 从网络分区恢复后,如何避免它继续以 Leader 自居?

单选题 · hard

  • A.对比任期后退为从者← 正确答案
  • B.对比节点 ID 让位他人
  • C.自动删除自己的日志
  • D.等待管理员介入处理

答案:A。Raft 用任期号解决“旧 Leader 复活”问题。旧 Leader 恢复通信后,会从其他节点处收到更高的任期号,发现自己的任期落后,于是自动降级为 Follower。这就像老领队回来发现新领队是“第 5 任”,自然服从。B 是 Bully 的做法,C 会破坏数据,D 违背自动恢复原则。

Q7. 如果多个 Raft 节点同时超时并各自成为候选者,接下来会发生什么?

单选题 · hard

  • A.多人一起当 Leader
  • B.各自分裂出独立集群
  • C.票数不足重新选举← 正确答案
  • D.立即人工介入处理

答案:C。多个候选者同时拉票会导致选票分散,没有谁拿到多数派票,选举失败。随后各节点会再次随机超时,随机性让下一轮有人更早发起选举,最终收敛出一个 Leader。A 不可能出现,B 是脑裂,D 违背系统自动恢复的设计初衷。

Q8. 以下哪些是 Leader 在分布式系统中的典型职责?

多选题 · mid

  • A.接收并处理全部写请求← 正确答案
  • B.把日志复制给 Follower← 正确答案
  • C.定期发送心跳保活← 正确答案
  • D.向每个节点发放奖励金

答案:ABC。Leader 的三大职责就是承接写请求、复制日志、发送心跳,对应领队的“看地图、派任务、报平安”。D 显然是干扰项,Leader 不会给节点“发工资”,分布式系统里没有奖金池。

Q9. 关于 Bully 算法与 Raft 算法的区别,下列说法正确的有哪些?

多选题 · extreme

  • A.Bully 比 ID,Raft 比票数← 正确答案
  • B.Bully 的 Leader 是 ID 最大← 正确答案
  • C.Raft 要求多数派支持← 正确答案
  • D.Bully 也用多数派防裂

答案:ABC。Bully 依赖节点编号比较,最大编号存活者胜出;Raft 依赖随机超时和多数派投票,因此 A、B、C 正确。D 错误——Bully 没有多数派仲裁机制,这正是它相比 Raft 在脑裂防护上的短板,也是生产系统更青睐 Raft 的原因。

Q10. 什么是分布式系统中的“脑裂”?

单选题 · easy

  • A.网络分区导致多个 Leader← 正确答案
  • B.单节点内存溢出故障
  • C.Leader 节点 CPU 持续过高
  • D.多个节点同时宕机恢复

答案:A。脑裂是网络分区导致系统内出现多个"Leader"、数据写入互不协调的故障场景,就像两个营地失联后各选各的领队,队伍彻底分裂。B 是内存故障,C 是性能问题,D 是宕机恢复,都与脑裂无关。