线性一致性 vs 顺序一致性#

// Raft 的线性一致性写入
public class RaftClient {
    public boolean write(String key, String value) {
        // 1. 把写入请求发送给 Leader
        Node leader = findLeader();
        if (leader == null) {
            return false; // 没有 Leader，无法线性写入
        }

        // 2. Leader 把日志复制到多数派节点
        int term = leader.getCurrentTerm();
        LogEntry entry = new LogEntry(term, key, value);
        boolean committed = leader.appendEntry(entry);

        if (!committed) {
            return false; // 多数派未达成一致
        }

        // 3. 此时写入已线性化（已提交到状态机）
        return true;
    }
}

// ZooKeeper 读操作（不经过 Leader）
public class ZKClient {
    // 方式1：读任意节点（顺序一致，不保证是最新的）
    public String read(String path) {
        Node node = zk.getConnection().getNode随便一个节点);
        return node.getData(); // 可能返回旧数据
    }

    // 方式2：Sync + 读 Leader（线性一致，但延迟高）
    public String linearizableRead(String path) {
        zk.sync(); // 强制与 Leader 同步
        return zk.getData(path, false, null);
    }
}

// 方式1：走 Leader（线性一致）
public String readViaLeader(String key) {
    Node leader = findLeader();
    if (leader == null) throw new NotLeaderException();

    // 确保自己是 Leader（可能已经过期）
    if (!leader.isStillLeader()) {
        throw new NotLeaderException(); // 重新找 Leader
    }

    // 读取本地状态机（Leader 的状态机一定是最新的）
    return leader.getStateMachine().read(key);
}

// 方式2：Lease Read（优化版，减少一次 RPC）
public String leaseRead(String key) {
    // Leader 在 electionTimeout 期间内，认为自己还是 Leader
    // 不需要发送心跳确认，直接读本地

    if (leader.isLeaseValid()) {
        return leader.getStateMachine().read(key); // 不发 RPC，直接读
    } else {
        // Lease 过期，需要走正常读流程
        return readViaLeader(key);
    }
}

// 方式3：Follower 读（通过 ReadIndex 优化）
public String readViaFollower(String key) {
    // 1. 向 Leader 发送 ReadIndex 请求，获取当前已提交的日志索引
    long commitIndex = leader.getCommitIndex();

    // 2. 等待本地状态机应用到 commitIndex
    follower.waitUntilApplied(commitIndex);

    // 3. 现在可以安全地读本地状态机
    return follower.getStateMachine().read(key);
}

// ❌ 错误代码：在 ZooKeeper 读后写，但没有保证线性一致
String data = zk.getData("/config", false, null);
if (data == null) {
    zk.create("/config", "initialized".getBytes()); // 可能创建失败，因为另一个节点已经创建了
}

// ✅ 方式1：用 watch 保证读后写（顺序一致）
Stat stat = new Stat();
String data = zk.getData("/config", watch, stat);
if (data == null) {
    try {
        zk.create("/config", "initialized".getBytes(), CreateMode.PERSISTENT);
    } catch (NodeExistsException e) {
        // 另一个线程已经创建，忽略
    }
}

// ✅ 方式2：用 Sync + 读（线性一致）
zk.sync("/config");
String data = zk.getData("/config", false, null);

// etcd 的读模式
// Linearizable：线性一致读（默认）
client.get("key"); // 走 Raft，保证读到最新

// Serializable：顺序一致读（更快）
client.get("key", WithMode(etcd.ReadModeSerializable)); // 不走 Raft，可能读到旧数据