zookeeper原理之投票的网络通信流程

通信流程图：

接收数据 Notification 和发送 ToSend

ToSender	Notification
leader；被推荐的服务器 sid zxid; 被推荐的服务器当前最新的事务 id peerEpoch; 被推荐的服务器当前所处的 epoch electionepoch；当前服务器所处的 epoch stat 当前服务器状态 sid 接收消息的服务器 sid（myid）	leader； //被推荐的服务器 sid zxid；被推荐的服务器最新事务 id peerEpoch; 被推荐的服务器当前所处的 epoch electionEpoch 选举服务器所处的 epoch stat；选举服务器当前的状态 sid；选举服务器的 sid

通信过程源码分析

每个 zk 服务启动后创建 socket 监听

protected Election createElectionAlgorithm(int electionAlgorithm){
    //….
    case 3:
        qcm = createCnxnManager();
        QuorumCnxManager.Listener listener = 
        qcm.listener;
        if(listener != null){
            listener.start();
        }
    // 启动监听listener 实现了线程，所以在 run 方法中可以看到构建ServerSocket 的请求，这里专门用来接收其他zkServer
    // 的投票请求
    // 这块后续再分析
    @Override
    public void run() {
            int numRetries = 0;
            InetSocketAddress addr;
            while((!shutdown) && (numRetries < 3)){
                try {
                    ss = new ServerSocket();
                }
            }
        }
    }

FastLeaderElection.lookForLeader

这个方法在前面分析过，里面会调用 sendNotifications 来发送投票请求

public Vote lookForLeader() throws InterruptedException {
     //省略部分代码
     sendNotifications(); //这个方法，会把当前zk 服务器的信息添加到 sendqueue
     /*
     * Loop in which we exchange 
    notifications until we find a leader
     */
     while ((self.getPeerState() == ServerState.LOOKING) &&
     //省略部分代码
}

FastLeaderElection.sendqueue

sendQueue 这个队列的数据，是通过 WorkerSender 来进行获取并发送的。而这个 WorkerSender 线程，在构建 fastLeaderElection 时，会启动

class WorkerSender extends ZooKeeperThread {
    public void run() {
        while (!stop) {
            try {//从队列中获取 ToSend 对象
                ToSend m = sendqueue.poll(3000, TimeUnit.MILLISECONDS);
                if(m == null) continue;
                process(m);
                //省略部分代码
                void process(ToSend m) {
                    ByteBuffer requestBuffer = buildMsg(m.state.ordinal(),
                    m.leader, m.zxid,
                    m.electionEpoch,
                    m.peerEpoch);
                    manager.toSend(m.sid, requestBuffer); // 这里就是调用 QuorumCnxManager
                                                        // 进行消息发送
                }
            }
        }
    }
}

QuorumCnxManager.toSend

public void toSend(Long sid, ByteBuffer b) {
 
        if (this.mySid == sid) { // 如果接受者是自己，直接放置到接收队列
            b.position(0);
            addToRecvQueue(new Message(b.duplicate(), sid));
        } else { // 否则发送到对应的发送队列上
            ArrayBlockingQueue<ByteBuffer> bq = new ArrayBlockingQueue<ByteBuffer>(SEND_CAPACITY);
            // 判断当前的 sid 是否已经存在于发送队列，如果是，则直接把已经存在的数据发送出去
            ArrayBlockingQueue<ByteBuffer> bqExisting = queueSendMap.putIfAbsent(sid, bq);
            if (bqExisting != null) {
                addToSendQueue(bqExisting, b);
            } else {
                addToSendQueue(bq, b);
            }
            connectOne(sid); // 连接申请调用链 connectOne-->initiateConnection-
                                // ->startConnection ， startConnection 就是发送方启动入口
        }
    }

startConnection

private boolean startConnection(Socket sock, Long sid) {
        // 省略部分代码
        if (sid > this.mySid) {
            // 为了防止重复建立连接，只允许 sid 大的主动连接 sid 小的
            closeSocket(sock);
        } else {
            // 构建一个发送线程和接收线程,负责针对当前连接的数据传递,后续的逻辑比较简单，就不做分析
            SendWorker sw = new SendWorker(sock, sid);
            RecvWorker rw = new RecvWorker(sock, din, sid, sw);
            sw.setRecv(rw);
        }
    }

SendWorker 会监听对应 sid 的阻塞队列，启动的时候回如果队列为空时会重新发送一次最前最后的消息，以防上一次处理是服务器异常退出，造成上一条消息未处理成功；然后就是不停监听队里，发现有消息时调用send 方法RecvWorker：RecvWorker 不停监听 socket 的 inputstream，读取消息放到消息接收队列中,消息放入队列中，qcm 的流程就完毕了。

QuorumCnxManager.Listener

listener 监听到客户端请求之后，开始处理消息

public void run() {
        // 省略部分代码
        while (!shutdown) {
            Socket client = ss.accept();
            setSockOpts(client);
            LOG.info("Received connection request" + client.getRemoteSocketAddress());
            if (quorumSaslAuthEnabled) {
                receiveConnectionAsync(client);
            } else {
                receiveConnection(client); // 接收客户端请求
            }
        }
    }

QuorumCnxManager.receiveConnection

public void receiveConnection(final Socket sock) {
        DataInputStream din = null;
        try {
            // 获取客户端的数据包
            din = new DataInputStream(new BufferedInputStream(sock.getInputStream()));
            handleConnection(sock, din);// 调用 handle 进行处理
        } catch (IOException e) {
            LOG.error("Exception handling connection, addr: {}, closing server connection",
                    sock.getRemoteSocketAddress());
            closeSocket(sock);
        }
    }

handleConnection

private void handleConnection(Socket sock, DataInputStream din)throws IOException {
             Long sid = null;
             try {
                 //获取客户端的 sid，也就是 myid
                 sid = din.readLong();
                if (sid < 0) { 
                    sid = din.readLong();
                    if (sid < this.mySid) {
                        //为了防止重复建立连接，只允许 sid 大的主动连接 sid 小的
                        SendWorker sw = senderWorkerMap.get(sid);
                        if (sw != null) {
                            sw.finish();//关闭连接
                        }
                        LOG.debug("Create new connection to server: " + sid);
                        closeSocket(sock);//关闭连接
                        connectOne(sid);//向 sid 发起连接
                    } else {//同样，构建一个 SendWorker 和RecvWorker 进行发送和接收数据
                        SendWorker sw = new
                        SendWorker(sock, sid);
                        RecvWorker rw = new
                        RecvWorker(sock, din, sid, sw);
                        sw.setRecv(rw);
                    }
                }
             }
        }