← 返回学习路线

SYSTEM

源码解析

Java基础源码解析system
src/content/notes/system/源码解析.md

源码解析

服务端

服务端程序的入口 QuorumPeerMain

public static void main(String[] args) {
    QuorumPeerMain main = new QuorumPeerMain();
    main.initializeAndRun(args);
}

initializeAndRun 的工作:

  • 解析启动参数

  • 提交周期任务,定时删除过期的快照

  • 初始化通信模型,默认是 NIO 通信

    // QuorumPeerMain#runFromConfig
    public void runFromConfig(QuorumPeerConfig config) {
        // 通信信组件初始化,默认是 NIO 通信
        ServerCnxnFactory cnxnFactory = ServerCnxnFactory.createFactory();
        // 初始化NIO 服务端socket,绑定2181 端口,可以接收客户端请求
        cnxnFactory.configure(config.getClientPortAddress(), config.getMaxClientCnxns(), false);
        // 启动 zk
        quorumPeer.start();
    }
  • 启动 zookeeper

    // QuorumPeer#start
    public synchronized void start() {
        if (!getView().containsKey(myid)) {
            throw new RuntimeException("My id " + myid + " not in the peer list");
        }
        // 冷启动数据恢复,将快照中数据恢复到 DataTree
        loadDataBase();
        // 启动通信工厂实例对象
        startServerCnxnFactory();
        try {
            adminServer.start();
        } catch (AdminServerException e) {
            LOG.warn("Problem starting AdminServer", e);
            System.out.println(e);
        }
        // 准备选举环境
        startLeaderElection();
        // 执行选举
        super.start();
    }

选举机制

环境准备

QuorumPeer#startLeaderElection 初始化选举环境:

synchronized public void startLeaderElection() {
    try {
        // Looking 状态,需要选举
        if (getPeerState() == ServerState.LOOKING) {
            // 选票组件: myid (serverid), zxid, epoch
            // 开始选票时,serverid 是自己,【先投自己】
            currentVote = new Vote(myid, getLastLoggedZxid(), getCurrentEpoch());
        }
    }
    if (electionType == 0) {
        try {
            udpSocket = new DatagramSocket(getQuorumAddress().getPort());
            // 响应投票结果线程
            responder = new ResponderThread();
            responder.start();
        } catch (SocketException e) {
            throw new RuntimeException(e);
        }
    }
    // 创建选举算法实例
    this.electionAlg = createElectionAlgorithm(electionType);
}
// zk总的发送和接收队列准备好
protected Election createElectionAlgorithm(int electionAlgorithm){
    // 负责选举过程中的所有网络通信,创建各种队列和集合
    QuorumCnxManager qcm = createCnxnManager();
    QuorumCnxManager.Listener listener = qcm.listener;
    if(listener != null){
        // 启动监听线程, 调用 client = ss.accept()阻塞,等待处理请求
        listener.start();
        // 准备好发送和接收队列准备
        FastLeaderElection fle = new FastLeaderElection(this, qcm);
        // 启动选举线程,【WorkerSender 和 WorkerReceiver】
        fle.start();
        le = fle;
    }
}

选举源码

当 Zookeeper 启动后,首先都是 Looking 状态,通过选举让其中一台服务器成为 Leader

执行 super.start() 相当于执行 QuorumPeer#run() 方法

public void run() {
    case LOOKING:
        // 进行选举,选举结束返回最终成为 Leader 胜选的那张选票
        setCurrentVote(makeLEStrategy().lookForLeader());
}

FastLeaderElection 类:

  • lookForLeader:选举

    public Vote lookForLeader() {
        // 正常启动中其他服务器都会向我发送一个投票,保存每个服务器的最新合法有效的投票
        HashMap<Long, Vote> recvset = new HashMap<Long, Vote>();
    	// 存储合法选举之外的投票结果
        HashMap<Long, Vote> outofelection = new HashMap<Long, Vote>();
    	// 一次选举的最大等待时间,默认值是0.2s
        int notTimeout = finalizeWait;
    	// 每发起一轮选举,logicalclock++,在没有合法的epoch 数据之前,都使用逻辑时钟代替
        synchronized(this){
            // 更新逻辑时钟,每进行一次选举,都需要更新逻辑时钟
            logicalclock.incrementAndGet();
            // 更新选票(serverid, zxid, epoch)
            updateProposal(getInitId(), getInitLastLoggedZxid(), getPeerEpoch());
        }
        // 广播选票,把自己的选票发给其他服务器
        sendNotifications();
        // 一轮一轮的选举直到选举成功
        while ((self.getPeerState() == ServerState.LOOKING) && (!stop)){ }
    }
  • sendNotifications:广播选票

    private void sendNotifications() {
        // 遍历投票参与者,给每台服务器发送选票
        for (long sid : self.getCurrentAndNextConfigVoters()) {
    		// 创建发送选票
            ToSend notmsg = new ToSend(...);
            // 把发送选票放入发送队列
            sendqueue.offer(notmsg);
        }
    }

FastLeaderElection 中有 WorkerSender 线程:

  • ToSend m = sendqueue.poll(3000, TimeUnit.MILLISECONDS):阻塞获取要发送的选票

  • process(m):处理要发送的选票

    manager.toSend(m.sid, requestBuffer):发送选票

    • if (this.mySid == sid):如果消息的接收者 sid 是自己,直接进入自己的 RecvQueue(自己投自己)

    • else:如果接收者是其他服务器,创建对应的发送队列或者复用已经存在的发送队列,把消息放入该队列

    • connectOne(sid):建立连接

      • sock.connect(electionAddr, cnxTO):建立与 sid 服务器的连接

      • initiateConnection(sock, sid):初始化连接

        startConnection(sock, sid):创建并启动发送器线程和接收器线程

        • dout = new DataOutputStream(buf):获取 Socket 输出流,向服务器发送数据
        • din = new DataInputStream(new BIS(sock.getInputStream()))):通过输入流读取对方发送过来的选票
        • if (sid > self.getId()):接收者 sid 比我的大,没有资格给对方发送连接请求的,直接关闭自己的客户端
        • SendWorker sw:初始化发送器,并启动发送器线程,线程 run 方法
          • while (running && !shutdown && sock != null):连接没有断开就一直运行
          • ByteBuffer b = pollSendQueue():从发送队列 SendQueue 中获取发送消息
          • lastMessageSent.put(sid, b):更新对于 sid 这台服务器的最近一条消息
          • send(b):执行发送
        • RecvWorker rw:初始化接收器,并启动接收器线程
          • din.readFully(msgArray, 0, length):输入流接收消息
          • addToRecvQueue(new Message(messagg, sid)):将消息放入接收消息 recvQueue 队列

FastLeaderElection 中有 WorkerReceiver 线程

  • response = manager.pollRecvQueue():从 RecvQueue 中阻塞获取出选举投票消息(其他服务器发送过来的)

状态同步

选举结束后,每个节点都需要根据角色更新自己的状态,Leader 更新状态为 Leader,其他节点更新状态为 Follower,整体流程:

  • Follower 需要让 Leader 知道自己的状态 (sid, epoch, zxid)
  • Leader 接收到信息,根据信息构建新的 epoch,要返回对应的信息给 Follower,Follower 更新自己的 epoch
  • Leader 需要根据 Follower 的状态,确定何种方式的数据同步 DIFF、TRUNC、SNAP,就是要以 Leader 服务器数据为准
    • DIFF:Leader 提交的 zxid 比 Follower 的 zxid 大,发送 Proposal 给 Follower 提交执行
    • TRUNC:Follower 的 zxid 比leader 的 zxid 大,Follower 要进行回滚
    • SNAP:Follower 没有任何数据,直接全量同步
  • 执行数据同步,当 Leader 接收到超过半数 Follower 的 Ack 之后,进入正常工作状态,集群启动完成

核心函数解析:

  • Leader 更新状态入口:Leader.lead()
    • zk.loadData():恢复数据到内存
    • cnxAcceptor = new LearnerCnxAcceptor():启动通信组件
      • s = ss.accept():等待其他 Follower 节点向 Leader 节点发送同步状态
      • LearnerHandler fh :接收到 Follower 的请求,就创建 LearnerHandler 对象
      • fh.start():启动线程,通过 switch-case 语法判断接收的命令,执行相应的操作
  • Follower 更新状态入口:Follower.followerLeader()
    • QuorumServer leaderServer = findLeader():查找 Leader
    • connectToLeader(addr, hostname) :与 Leader 建立连接
    • long newEpochZxid = registerWithLeader(Leader.FOLLOWERINFO):向 Leader 注册

主从工作

Leader:主服务的工作流程

Follower:从服务的工作流程,核心函数为 Follower#followLeader()

  • readPacket(qp):读取信息

  • processPacket(qp):处理信息

    protected void processPacket(QuorumPacket qp) throws Exception{
        switch (qp.getType()) {
            case Leader.PING:
                break;
            case Leader.PROPOSAL:
                break;
            case Leader.COMMIT:
                break;
            case Leader.COMMITANDACTIVATE:
                break;
            case Leader.UPTODATE:
                break;
            case Leader.REVALIDATE:
                break;
            case Leader.SYNC:
                break;
            default:
                break;
        }
    }

客户端