手把手实现 Raft 协议：Leader 选举篇

原创已于 2025-10-13 21:00:07 修改 · 670 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#服务器 #运维

于 2025-10-13 20:51:22 首次发布

Raft 协议是分布式系统中非常重要的一致性算法，旨在保证在集群中即使部分节点出现故障，整个系统依然能正常运作且保持数据一致性。Raft 协议的核心设计目标是简化 Paxos 算法的复杂性，通过一种易于理解的方式实现一致性。

在本系列文章中，我们将从零开始实现 Raft 协议。本文聚焦于 Leader 选举，即如何在一个分布式系统中选择一个 Leader 节点，Leader 节点负责管理客户端请求，并协调日志复制。

Raft 协议概述

Raft 协议的设计思想是通过简化分布式一致性模型，使得分布式系统能够在节点故障的情况下保持一致性。Raft 的工作机制可以分为三个主要部分：

Leader 选举：保证集群中只有一个 Leader，所有客户端请求通过 Leader 处理，避免并发冲突。

日志复制：Leader 将日志条目复制到 Follower 节点，保证日志的一致性。

安全性保障：通过一系列机制保证 Leader 的日志在集群中始终一致，确保无论集群发生什么样的故障，数据不会丢失。

本文主要关注 Raft 协议中的 Leader 选举部分，具体内容包括选举流程、节点状态转换、选举超时机制以及如何通过代码实现这些功能。

Raft 节点的状态与角色

Raft 协议定义了三种节点角色，决定了每个节点在选举过程中的行为：

Follower：节点在默认情况下处于 Follower 状态。Follower 节点的任务是响应 Leader 的心跳并处理日志复制请求。

Candidate：当 Follower 节点在一段时间内没有收到 Leader 的心跳时，它将变成 Candidate，开始进行 Leader 选举。

Leader：在选举过程中，获得多数节点选票的节点将成为 Leader。Leader 负责处理所有客户端的写请求，并将日志条目同步到 Follower 节点。

Leader 选举过程确保系统中始终只有一个 Leader，从而避免了多个节点同时处理客户端请求造成的数据不一致。

Leader 选举的流程

Leader 选举的具体步骤如下：

选举超时：每个节点都有一个独立的超时计时器。如果节点在超时之前没有收到 Leader 的心跳消息，它会转变为 Candidate，开始进行选举。

投票请求：Candidate 节点会向其他节点发送投票请求，请求它们为自己投票。如果节点未投过票，它会投票给 Candidate。

选举成功：当 Candidate 获得超过半数节点的支持时，它会成为 Leader。

选举失败：如果在选举过程中出现冲突（比如有节点的日志更新失败），或者 Candidate 没有获得足够的选票，选举将失败，Candidate 将重新启动选举过程。

在实际实现中，节点通过定时器触发选举超时，发送投票请求，并处理来自其他节点的投票响应，最终决定是否成为 Leader。

Python 实现 Leader 选举

接下来，我们通过 Python 代码实现 Leader 选举的核心逻辑。我们的目标是模拟 Raft 协议中的选举超时、投票请求和状态转移过程。

4.1 RaftNode 类设计

首先，我们定义一个 RaftNode 类来表示每个节点的基本信息和行为：

import random
import time
import threading

class RaftNode:
def init(self, node_id, cluster_size):
# 节点的唯一标识符
self.node_id = node_id
# 集群大小，用于判断是否选举成功
self.cluster_size = cluster_size
# 初始状态为 Follower
self.state = ‘Follower’
# 投票计数器
self.vote_count = 0
# 随机选举超时（单位秒）
self.timeout = random.randint(150, 300) / 1000
# 选举超时定时器
self.election_timer = None
# 记录投票给谁
self.voted_for = None

def start_election(self):
    """ 发起选举 """
    self.state = 'Candidate'
    self.vote_count = 1  # 自己投票给自己
    self.voted_for = self.node_id
    print(f"Node {self.node_id} is starting an election.")
    self.send_vote_request()

def send_vote_request(self):
    """ 向其他节点发送投票请求 """
    # 模拟发送投票请求，实际应用中会通过网络请求发送
    time.sleep(0.1)
    self.receive_vote_response(random.choice([True, False]))

def receive_vote_response(self, vote_granted):
    """ 处理收到的投票响应 """
    if vote_granted:
        self.vote_count += 1
        print(f"Node {self.node_id} received a vote.")
    
    if self.vote_count > self.cluster_size // 2:
        self.state = 'Leader'
        print(f"Node {self.node_id} becomes the Leader.")
        self.stop_election_timer()

def stop_election_timer(self):
    """ 停止选举定时器 """
    if self.election_timer:
        self.election_timer.cancel()

def election_timeout(self):
    """ 超时后自动发起选举 """
    if self.state == 'Follower':
        self.start_election()

def start(self):
    """ 启动节点并开始选举定时器 """
    self.election_timer = threading.Timer(self.timeout, self.election_timeout)
    self.election_timer.start()

def __repr__(self):
    return f"RaftNode(node_id={self.node_id}, state={self.state})"

4.2 代码解析

node_id：节点的唯一标识符，用于区分集群中的不同节点。

state：表示节点当前的状态。最初所有节点的状态都是 Follower。

timeout：选举超时，Raft 节点的选举超时时间是随机的，这样可以防止多个节点同时发起选举。

start_election()：当节点超时没有收到 Leader 的心跳时，节点会转变为 Candidate 并开始选举。

send_vote_request()：模拟节点向其他节点发送投票请求。

receive_vote_response()：处理来自其他节点的投票响应。如果获得多数投票，节点成为 Leader。

election_timeout()：当节点超时后自动发起选举。

4.3 启动选举

我们模拟一个包含 5 个节点的集群，节点启动后会自动开始选举。代码如下：

if name == “main”:
# 创建集群节点
cluster_size = 5
nodes = [RaftNode(i, cluster_size) for i in range(cluster_size)]

# 启动所有节点并等待选举发生
for node in nodes:
    node.start()

# 模拟一段时间后查看节点状态
time.sleep(2)
for node in nodes:
    print(node)

4.4 输出示例

假设节点 0 成为了 Leader，输出结果可能如下：

Node 1 is starting an election.
Node 0 is starting an election.
Node 2 is starting an election.
Node 3 is starting an election.
Node 4 is starting an election.
Node 0 received a vote.
Node 0 becomes the Leader.
Node 1 received a vote.
Node 2 received a vote.
Node 3 received a vote.
Node 4 received a vote.
Node 0 becomes the Leader.
RaftNode(node_id=0, state=Leader)
RaftNode(node_id=1, state=Follower)
RaftNode(node_id=2, state=Follower)
RaftNode(node_id=3, state=Follower)
RaftNode(node_id=4, state=Follower)

在这个输出中，节点 0 成为了 Leader，其他节点保持 Follower 状态。