java 实现简易基于Dledger 的选举

java 实现简易基于Dledger 的选举

1. 定义 Dledger 节点类，包含节点的状态、日志存储、选举和日志复制逻辑

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

// Dledger 节点类，包含节点的状态、日志存储、选举和日志复制逻辑
class DledgerNode {
    // 选举超时时间的最小值（毫秒）
    private static final int ELECTION_TIMEOUT_MIN = 150;
    // 选举超时时间的最大值（毫秒）
    private static final int ELECTION_TIMEOUT_MAX = 300;
    // 心跳间隔时间（毫秒）
    private static final int HEARTBEAT_INTERVAL = 50;

    // 当前节点所处的任期号
    private long currentTerm;
    // 当前节点投票给的节点 ID，-1 表示未投票
    private int votedFor;
    // 存储日志条目的列表
    private List<LogEntry> log;
    // 节点的状态，0 表示追随者，1 表示候选人，2 表示领导者
    private int state;
    // 当前节点的 ID
    private int selfId;
    // 集群中其他节点的 ID 列表
    private List<Integer> peers;
    // 用于定时任务的调度器
    private ScheduledExecutorService scheduler;
    // 选举超时时间（毫秒）
    private long electionTimeout;
    // 候选人收到的投票数
    private int votesReceived;

    // 构造函数，用于初始化节点的相关信息
    public DledgerNode(int selfId, List<Integer> peers) {
        // 初始任期号为 0
        this.currentTerm = 0;
        // 初始未投票
        this.votedFor = -1;
        // 初始化日志列表
        this.log = new ArrayList<>();
        // 初始状态为追随者
        this.state = 0;
        // 设置当前节点的 ID
        this.selfId = selfId;
        // 设置集群中其他节点的 ID 列表
        this.peers = peers;
        // 创建一个单线程的调度器
        this.scheduler = Executors.newScheduledThreadPool(1);
        // 重置选举超时时间
        resetElectionTimeout();
    }

    // 重置选举超时时间的方法
    private void resetElectionTimeout() {
        // 创建一个随机数生成器
        Random random = new Random();
        // 生成一个介于 ELECTION_TIMEOUT_MIN 和 ELECTION_TIMEOUT_MAX 之间的随机数作为选举超时时间
        this.electionTimeout = random.nextInt(ELECTION_TIMEOUT_MAX - ELECTION_TIMEOUT_MIN + 1) + ELECTION_TIMEOUT_MIN;
        // 调度一个定时任务，在选举超时时间后启动选举
        scheduler.schedule(this::startElection, electionTimeout, TimeUnit.MILLISECONDS);
    }

    // 启动选举的方法
    private void startElection() {
        // 将节点状态设置为候选人
        state = 1;
        // 任期号加 1
        currentTerm++;
        // 投票给自己
        votedFor = selfId;
        // 初始收到的投票数为 1（自己的一票）
        votesReceived = 1;

        // 创建一个投票请求对象
        VoteRequest request = new VoteRequest(currentTerm, selfId, getLastLogIndex(), getLastLogTerm());
        // 向集群中的每个节点发送投票请求
        for (int peer : peers) {
            sendVoteRequest(peer, request);
        }
    }

    // 发送投票请求的方法
    private void sendVoteRequest(int peer, VoteRequest request) {
        // 模拟网络通信，实际中需要使用网络库
        // 调用 handleVoteRequest 方法处理投票请求并获取响应
        VoteResponse response = handleVoteRequest(peer, request);
        // 处理投票响应
        handleVoteResponse(response);
    }

    // 处理投票请求的方法
    private VoteResponse handleVoteRequest(int peer, VoteRequest request) {
        // 如果请求的任期号小于当前节点的任期号，拒绝投票
        if (request.term < currentTerm) {
            return new VoteResponse(currentTerm, false);
        }
        // 如果请求的任期号大于当前节点的任期号，更新当前节点的任期号，将状态设置为追随者，重置投票信息
        if (request.term > currentTerm) {
            currentTerm = request.term;
            state = 0;
            votedFor = -1;
        }
        // 如果当前节点未投票或者已经投票给该候选人，并且候选人的日志至少和自己一样新，则授予投票
        if ((votedFor == -1 || votedFor == request.candidateId) &&
                (request.lastLogTerm > getLastLogTerm() ||
                        (request.lastLogTerm == getLastLogTerm() && request.lastLogIndex >= getLastLogIndex()))) {
            votedFor = request.candidateId;
            // 重置选举超时时间
            resetElectionTimeout();
            return new VoteResponse(currentTerm, true);
        }
        // 否则拒绝投票
        return new VoteResponse(currentTerm, false);
    }

    // 处理投票响应的方法
    private void handleVoteResponse(VoteResponse response) {
        // 如果响应的任期号大于当前节点的任期号，更新当前节点的任期号，将状态设置为追随者，重置投票信息
        if (response.term > currentTerm) {
            currentTerm = response.term;
            state = 0;
            votedFor = -1;
            // 重置选举超时时间
            resetElectionTimeout();
        }
        // 如果当前节点是候选人，并且收到了投票，则增加投票数
        if (state == 1 && response.voteGranted) {
            votesReceived++;
            // 如果收到的投票数超过集群节点数的一半，则当选为领导者
            if (votesReceived > peers.size() / 2) {
                state = 2;
                System.out.println("Node " + selfId + " has been elected as the leader in term " + currentTerm);
                // 开始发送心跳
                startSendingHeartbeats();
            }
        }
    }

    // 开始发送心跳的方法
    private void startSendingHeartbeats() {
        // 调度一个定时任务，每隔 HEARTBEAT_INTERVAL 毫秒发送一次心跳
        scheduler.scheduleAtFixedRate(() -> {
            // 创建一个追加日志请求对象，entries 为空表示这是一个心跳请求
            AppendEntriesRequest request = new AppendEntriesRequest(currentTerm, selfId, getLastLogIndex(), getLastLogTerm(), new LogEntry[0], getCommitIndex());
            // 向集群中的每个节点发送追加日志请求
            for (int peer : peers) {
                sendAppendEntriesRequest(peer, request);
            }
        }, 0, HEARTBEAT_INTERVAL, TimeUnit.MILLISECONDS);
    }

    // 发送追加日志请求的方法
    private void sendAppendEntriesRequest(int peer, AppendEntriesRequest request) {
        // 模拟网络通信，实际中需要使用网络库
        // 调用 handleAppendEntriesRequest 方法处理追加日志请求并获取响应
        AppendEntriesResponse response = handleAppendEntriesRequest(peer, request);
        // 处理追加日志响应
        handleAppendEntriesResponse(response);
    }

    // 处理追加日志请求的方法
    private AppendEntriesResponse handleAppendEntriesRequest(int peer, AppendEntriesRequest request) {
        // 如果请求的任期号小于当前节点的任期号，拒绝请求
        if (request.term < currentTerm) {
            return new AppendEntriesResponse(currentTerm, false);
        }
        // 如果请求的任期号大于当前节点的任期号，更新当前节点的任期号，将状态设置为追随者，重置投票信息
        if (request.term > currentTerm) {
            currentTerm = request.term;
            state = 0;
            votedFor = -1;
        }
        // 重置选举超时时间
        resetElectionTimeout();
        // 简单处理日志追加逻辑
        // 如果前一条日志的索引超出了日志列表的范围，或者前一条日志的任期号不匹配，则拒绝请求
        if (request.prevLogIndex >= 0 && (request.prevLogIndex >= log.size() || log.get((int) request.prevLogIndex).term != request.prevLogTerm)) {
            return new AppendEntriesResponse(currentTerm, false);
        }
        // 遍历要追加的日志条目
        for (LogEntry entry : request.entries) {
            // 如果要追加的日志位置已经存在日志，则替换该位置的日志
            if (request.prevLogIndex + 1 + log.indexOf(entry) < log.size()) {
                log.set((int) (request.prevLogIndex + 1 + log.indexOf(entry)), entry);
            } else {
                // 否则将日志追加到日志列表的末尾
                log.add(entry);
            }
        }
        // 如果领导者的提交索引大于当前节点的提交索引，更新当前节点的提交索引
        if (request.leaderCommit > getCommitIndex()) {
            // 更新提交索引
        }
        // 返回追加成功的响应
        return new AppendEntriesResponse(currentTerm, true);
    }

    // 处理追加日志响应的方法
    private void handleAppendEntriesResponse(AppendEntriesResponse response) {
        // 如果响应的任期号大于当前节点的任期号，更新当前节点的任期号，将状态设置为追随者，重置投票信息
        if (response.term > currentTerm) {
            currentTerm = response.term;
            state = 0;
            votedFor = -1;
            // 重置选举超时时间
            resetElectionTimeout();
        }
    }

    // 获取最后一条日志索引的方法
    private long getLastLogIndex() {
        return log.size() - 1;
    }

    // 获取最后一条日志任期号的方法
    private long getLastLogTerm() {
        // 如果日志列表为空，返回 0
        if (log.isEmpty()) {
            return 0;
        }
        // 否则返回最后一条日志的任期号
        return log.get(log.size() - 1).term;
    }

    // 获取提交索引的方法，这里简单返回最后一条日志的索引
    private long getCommitIndex() {
        return getLastLogIndex();
    }

    @Override
    public String toString() {
        return "DledgerNode{" +
                "currentTerm=" + currentTerm +
                ", votedFor=" + votedFor +
                ", log=" + log +
                ", state=" + state +
                ", selfId=" + selfId +
                ", peers=" + peers +
                ", scheduler=" + scheduler +
                ", electionTimeout=" + electionTimeout +
                ", votesReceived=" + votesReceived +
                '}';
    }
}

2. 定义日志条目类

// 日志条目类，用于存储日志的任期号和具体数据
class LogEntry {
    // 该日志条目的任期号，用于标识日志的先后顺序
    long term;
    // 日志条目的具体数据内容
    String data;

    // 构造函数，用于初始化日志条目的任期号和数据
    public LogEntry(long term, String data) {
        this.term = term;
        this.data = data;
    }
}

// 投票请求类，用于在选举过程中向其他节点请求投票
class VoteRequest {
    // 候选人当前所处的任期号
    long term;
    // 候选人的节点 ID
    int candidateId;
    // 候选人最后一条日志的索引
    long lastLogIndex;
    // 候选人最后一条日志的任期号
    long lastLogTerm;

    // 构造函数，用于初始化投票请求的相关信息
    public VoteRequest(long term, int candidateId, long lastLogIndex, long lastLogTerm) {
        this.term = term;
        this.candidateId = candidateId;
        this.lastLogIndex = lastLogIndex;
        this.lastLogTerm = lastLogTerm;
    }
}

// 投票响应类，用于对投票请求进行回应
class VoteResponse {
    // 当前节点的任期号
    long term;
    // 是否授予投票的标志，true 表示授予，false 表示拒绝
    boolean voteGranted;

    // 构造函数，用于初始化投票响应的相关信息
    public VoteResponse(long term, boolean voteGranted) {
        this.term = term;
        this.voteGranted = voteGranted;
    }
}

// 追加日志请求类，用于领导者向追随者发送日志追加请求
class AppendEntriesRequest {
    // 领导者当前所处的任期号
    long term;
    // 领导者的节点 ID
    int leaderId;
    // 要追加日志的前一条日志的索引
    long prevLogIndex;
    // 要追加日志的前一条日志的任期号
    long prevLogTerm;
    // 要追加的日志条目数组
    LogEntry[] entries;
    // 领导者当前的提交索引
    long leaderCommit;

    // 构造函数，用于初始化追加日志请求的相关信息
    public AppendEntriesRequest(long term, int leaderId, long prevLogIndex, long prevLogTerm, LogEntry[] entries, long leaderCommit) {
        this.term = term;
        this.leaderId = leaderId;
        this.prevLogIndex = prevLogIndex;
        this.prevLogTerm = prevLogTerm;
        this.entries = entries;
        this.leaderCommit = leaderCommit;
    }
}

// 追加日志响应类，用于追随者对追加日志请求进行回应
class AppendEntriesResponse {
    // 当前节点的任期号
    long term;
    // 日志追加是否成功的标志，true 表示成功，false 表示失败
    boolean success;

    // 构造函数，用于初始化追加日志响应的相关信息
    public AppendEntriesResponse(long term, boolean success) {
        this.term = term;
        this.success = success;
    }
}

3. Dledger 的测试用例

import java.util.Arrays;
import java.util.List;

public class DledgerTest {
    public static void main(String[] args) {
        // 定义集群中节点的 ID 列表
        List<Integer> peers = Arrays.asList(1, 2, 3);
        // 创建节点 1
        DledgerNode node1 = new DledgerNode(1, peers);
//        System.out.println(node1);
        // 创建节点 2
        DledgerNode node2 = new DledgerNode(2, peers);
//        System.out.println(node2);
        // 创建节点 3
        DledgerNode node3 = new DledgerNode(3, peers);
//        System.out.println(node3);
        try {
            // 让主线程休眠 5 秒，以便观察节点的选举和日志复制过程
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // 处理线程中断异常
            e.printStackTrace();
        }

    }
}