5-zookeeper原理之leader选举源码分析

一，Zookeeper的一致性

1，Zookeeper的来源

zookeeper 的来源，是来自于 google chubby。为了解决在分布式环境下，如何从多个 server 中选举出 master server。那么这多个 server 就需要涉及到一致性问题，这个一致性体现的是多个server 就 master 这个投票在分布式环境下达成一致性。简单来说就是最终听谁的。但是在网络环境中由于网络的不可靠性，会存在消息丢失和或者被篡改等问题。所以如何在这样一个环境中快速并且正确的在多个server 中对某一个数据达成一致性并且保证不论发生任何异常，都不会破坏整个系统一致性呢？

所以在 Lamport 大神设计了一套 Paxos 的算法，多个 server 基于这个算法就可以达成一致。而 google chubby 就是基于 paxos 算法的实现，用来实现分布式锁服务。并且提供了 master 选举的服务

2，Paxos在Chubby中的应用

Chubby 本来应该设计成一个包含 Paxos 算法的协议库，使得应用程序可以基于这个库方便的使用 Paxos 算法，但是它并没有这么做，而是把 Chubby 设计成了一个需要访问中心化节点的分布式锁服务。既然是一个服务，那么它肯定需要是一个高可靠的服务。所以 Chubby 被构建为一个集群，集群中存在一个中心节点（MASTER），采用 Paxos 协议，通过投票的方式来选举一个获得过半票数的服务器作为 Master，在 chubby 集群中，每个服务器都会维护一份数据的副本，在实际的运行过程中， 只有 master 服务器能执行事务操作，其他服务器都是使用paxos协议从master节点同步最新的数据。而 zookeeper 是 chubby 的开源实现，所以实现原理和 chubby 基本是一致的。

3，ZooKeeper的一致性是什么情况

Zookeeper 的一致性，体现的是什么一致呢？

在 zookeeper 集群内部的数据副本同步，是基于过半提交的策略，意味着它是最终一致性。并不满足强一致的要求。

其实正确来说，zookeeper 是一个顺序一致性模型。由于 zookeeper 设计出来是提供分布式锁服务，那么意味着它本身需要实现顺序一致性

顺序一致性是在分布式环境中实现分布式锁的基本要求，比如当一个多个程序来争抢锁，如果 clientA 获得锁以后，后续所有来争抢锁的程序看到的锁的状态都应该是被 clientA 锁定了，而不是其他状态。

4，什么是顺序一致性

假如说 zookeeper 是一个最终一致性模型，那么他会发生什么情况？

ClientA/B/C 假设只串行执行， clientA 更新 zookeeper 上的一个值 x。

ClientB 和 clientC 分别读取集群的不同副本，返回的 x 的值是不一样的。

clientC 的读取操作是发生在 clientB 之后，但是却读到了过期的值。很明显，这是一种弱一致模型。如果用它来实现锁机制是有问题的。

顺序一致性提供了更强的一致性保证，从时间轴来看，B0 发生在 A0 之前，读取的值是 0，B2 发生在 A0 之后，读取到的x 的值为 1.而读操作 B1/C0/C1 和写操作 A0 在时间轴上有重叠，因此他们可能读到旧的值为 0，也可能读到新的值 1. 但是在强顺序一致性模型中，如果 B1 得到的 x 的值为 1，那么 C1 看到的值也一定是 1.

由于网络的延迟以及系统本身执行请求的不确定性，会导致请求发起的早的客户端不一定会在服务端执行得早。最终以服务端执行的结果为准。

简单来说：顺序一致性是针对单个操作，单个数据对象。属于 CAP 中 C这个范畴。一个数据被更新后，能够立马被后续的读操作读到。

但是 zookeeper 的顺序一致性实现是缩水版的。

zookeeper 不保证在每个实例中，两个不同的客户端具有相同的zookeeper 数据视图，由于网络延迟等因素，一个客户端可能会在另外一个客户端收到更改通知之前执行更新，

考虑到 2 个客户端 A 和 B 的场景，如果 A 把 znode /a 的值从 0 设置为1，然后告诉客户端 B 读取 /a， 则客户端 B 可能会读取到旧的值 0，具体取决于他连接到那个服务器，如果客户端 A 和 B 要读取必须要读取到相同的值，那么 client B 在读取操作之前执行 sync 方法。

除此之外，zookeeper 基于 zxid 以及阻塞队列的方式来实现请求的顺序一致性。如果一个 client 连接到一个最新的 follower 上，那么它 read 读取到了最新的数据，然后 client 由于网络原因重新连接到 zookeeper 节点，而这个时候连接到一个还没有完成数据同步的 follower 节点，那么这一次读到的数据不久是旧的数据吗？实际上zookeeper 处理了这种情况，client 会记录自己已经读取到的最大的 zxid，如果 client 重连到 server 发现 client 的 zxid 比自己大。连接会失败

5，Single System Image 的理解

zookeeper 官网还说它保证了“Single System Image”，其解释为“A clientwill see the same view of the service regardless of the server that it connects to.”。实际上看来这个解释还是有一点误导性的。其实由上面 zxid的原理可以看出，它表达的意思是“client 只要连接过一次 zookeeper，就不会有历史的倒退”。

二，leader 选举的原理

leader 选举存在与两个阶段中，一个是服务器启动时的 leader 选举。 另一个是运行过程中 leader 节点宕机导致的 leader 选举 ；

分析选举的原理之前，先了解几个重要的参数

服务器 ID（myid）

比如有三台服务器，编号分别是 1,2,3。

编号越大在选择算法中的权重越大。

zxid 事务 id

值越大说明数据越新，在选举算法中的权重也越大

逻辑时钟（epoch – logicalclock）

或者叫投票的次数，同一轮投票过程中的逻辑时钟值是相同的。每投完一次票这个数据就会增加，然后与接收到的其它服务器返回的投票信息中的数值相比，根据不同的值做出不同的判断。

选举状态

LOOKING，竞选状态。

FOLLOWING，随从状态，同步 leader 状态，参与投票。

OBSERVING，观察状态,同步 leader 状态，不参与投票。

LEADING，领导者状态。

1，服务器启动时的 leader选举

每个节点启动的时候状态都是 LOOKING ，处于 观望 状态，接下来就开始进行选主流程

若进行 Leader 选举，则至少需要两台机器，这里选取 3 台机器组成的服务器集群为例。在集群初始化阶段，当有一台服务器 Server1 启动时，其单独无法进行和完成 Leader 选举，当第二台服务器 Server2 启动时，此时两台机器可以相互通信，每台机器都试图找到 Leader，于是进入 Leader选举过程。选举过程如下

(1) 每个 Server 发出一个投票。由于是初始情况，Server1 和 Server2 都会将自己作为 Leader 服务器来进行投票，每次投票会包含所推举的服务器的 myid 和 ZXID、epoch，使用(myid, ZXID,epoch)来表示，此时 Server1 的投票为(1, 0)，Server2 的投票为(2, 0)，然后各自将这个投票发给集群中其他机器。

(2) 接受来自各个服务器的投票。集群的每个服务器收到投票后，首先判断该投票的有效性，如检查是否是本轮投票（epoch）、是否来自LOOKING 状态的服务器。

(3) 处理投票。针对每一个投票，服务器都需要将别人的投票和自己的投票进行 PK，PK 规则如下

i. 优先比较 epoch

ii. 其次检查 ZXID。ZXID 比较大的服务器优先作为 Leader

iii. 如果 ZXID 相同，那么就比较 myid。myid 较大的服务器作为Leader 服务器。

对于 Server1 而言，它的投票是(1, 0)，接收 Server2 的投票为(2, 0)，首先会比较两者的 ZXID，均为 0，再比较 myid，此时 Server2 的myid 最大，于是更新自己的投票为(2, 0)，然后重新投票，对于Server2 而言，其无须更新自己的投票，只是再次向集群中所有机器发出上一次投票信息即可。

(4) 统计投票。每次投票后，服务器都会统计投票信息，判断是否已经有过半机器接受到相同的投票信息，对于 Server1、Server2 而言，都统计出集群中已经有两台机器接受了(2, 0)的投票信息，此时便认为已经选出了 Leader。

(5) 改变服务器状态。一旦确定了 Leader，每个服务器就会更新自己的状态，如果是 Follower，那么就变更为 FOLLOWING，如果是 Leader，就变更为 LEADING。

2，运行过程中的 leader

当集群中的 leader 服务器出现宕机或者不可用的情况时，那么整个集群将无法对外提供服务，而是进入新一轮的 Leader 选举，服务器运行期间的 Leader 选举和启动时期的 Leader 选举基本过程是一致的。

(1) 变更状态。Leader 挂后，余下的非 Observer 服务器都会将自己的服务器状态变更为 LOOKING，然后开始进入 Leader 选举过程。

(2) 每个 Server 会发出一个投票。在运行期间，每个服务器上的 ZXID 可能不同，此时假定 Server1 的 ZXID 为 123，Server3 的 ZXID 为 122；在第一轮投票中，Server1 和 Server3 都会投自己，产生投票(1, 123)，(3, 122)，然后各自将投票发送给集群中所有机器。接收来自各个服务器的投票。与启动时过程相同。

(3) 处理投票。与启动时过程相同，此时，Server1 将会成为 Leader。

(4) 统计投票。与启动时过程相同。

(5) 改变服务器的状态。与启动时过程相同

三，leader选举源码分析

对于 zk 的 leader 选举，并不是由客户端来触发，而是在启动的时候会触发一次选举。可以直接去看启动脚本 zkServer.sh 中的运行命令。

ZOOMAIN 就是 QuorumPeerMain。

1，QuorumPeerMain.main（）

main 方法中，调用了 initializeAndRun 进行初始化并且运行。

    public static void main(String[] args) {
        QuorumPeerMain main = new QuorumPeerMain();
        
            main.initializeAndRun(args);
       
        LOG.info("Exiting normally");
        ServiceUtils.requestSystemExit(ExitCode.EXECUTION_FINISHED.getValue());
    }

2，initializeAndRun（）

    protected void initializeAndRun(String[] args) throws ConfigException, IOException, AdminServerException {
        //设置配置参数，如果 args 不为空，可以基于外部的配置路径来进行解析
        QuorumPeerConfig config = new QuorumPeerConfig();
        if (args.length == 1) {
            config.parse(args[0]);
        }

        //  这里启动了一个线程，来定时对日志进行清理
        DatadirCleanupManager purgeMgr = new DatadirCleanupManager(
            config.getDataDir(),
            config.getDataLogDir(),
            config.getSnapRetainCount(),
            config.getPurgeInterval());
        purgeMgr.start();
        //如果是集群模式，会调用 runFromConfig.servers 实际就是我们在 zoo.cfg 里面配置的集群节点
        if (args.length == 1 && config.isDistributed()) {
            runFromConfig(config);
        } else {//否则直接运行单机模式
            LOG.warn("Either no config or no quorum defined in config, running in standalone mode");
            ZooKeeperServerMain.main(args);
        }
    }

3，runFromConfig（）

从名字可以看出来，是基于配置文件来进行启动。所以整个方法都是对参数进行解析和设置 ， 因为这些参数暂时还没用到，所以没必要去看。直接看核心的代码quorumPeer.start()， 启动一个线程，那么从这句代码可以看出来QuorumPeer 实际是继承了线程。那么它里面一定有一个 run 方法

    public void runFromConfig(QuorumPeerConfig config) throws IOException, AdminServerException {
        try {
            ManagedUtil.registerLog4jMBeans();
        } catch (JMException e) {
            LOG.warn("Unable to register log4j JMX control", e);
        }

        LOG.info("Starting quorum peer, myid=" + config.getServerId());
        final MetricsProvider metricsProvider;
        try {
            metricsProvider = MetricsProviderBootstrap.startMetricsProvider(
                config.getMetricsProviderClassName(),
                config.getMetricsProviderConfiguration());
        } catch (MetricsProviderLifeCycleException error) {
            throw new IOException("Cannot boot MetricsProvider " + config.getMetricsProviderClassName(), error);
        }
        try {
            ServerMetrics.metricsProviderInitialized(metricsProvider);
            ProviderRegistry.initialize();
            ServerCnxnFactory cnxnFactory = null;
            ServerCnxnFactory secureCnxnFactory = null;

            if (config.getClientPortAddress() != null) {
                cnxnFactory = ServerCnxnFactory.createFactory();
                cnxnFactory.configure(config.getClientPortAddress(), config.getMaxClientCnxns(), config.getClientPortListenBacklog(), false);
            }

            if (config.getSecureClientPortAddress() != null) {
                secureCnxnFactory = ServerCnxnFactory.createFactory();
                secureCnxnFactory.configure(config.getSecureClientPortAddress(), config.getMaxClientCnxns(), config.getClientPortListenBacklog(), true);
            }

            quorumPeer = getQuorumPeer();
            quorumPeer.setTxnFactory(new FileTxnSnapLog(config.getDataLogDir(), config.getDataDir()));
            quorumPeer.enableLocalSessions(config.areLocalSessionsEnabled());
            quorumPeer.enableLocalSessionsUpgrading(config.isLocalSessionsUpgradingEnabled());
            //quorumPeer.setQuorumPeers(config.getAllMembers());
            quorumPeer.setElectionType(config.getElectionAlg());
            quorumPeer.setMyid(config.getServerId());
            quorumPeer.setTickTime(config.getTickTime());
            quorumPeer.setMinSessionTimeout(config.getMinSessionTimeout());
            quorumPeer.setMaxSessionTimeout(config.getMaxSessionTimeout());
            quorumPeer.setInitLimit(config.getInitLimit());
            quorumPeer.setSyncLimit(config.getSyncLimit());
            quorumPeer.setConnectToLearnerMasterLimit(config.getConnectToLearnerMasterLimit());
            quorumPeer.setObserverMasterPort(config.getObserverMasterPort());
            quorumPeer.setConfigFileName(config.getConfigFilename());
            quorumPeer.setClientPortListenBacklog(config.getClientPortListenBacklog());
            quorumPeer.setZKDatabase(new ZKDatabase(quorumPeer.getTxnFactory()));
            quorumPeer.setQuorumVerifier(config.getQuorumVerifier(), false);
            if (config.getLastSeenQuorumVerifier() != null) {
                quorumPeer.setLastSeenQuorumVerifier(config.getLastSeenQuorumVerifier(), false);
            }
            quorumPeer.initConfigInZKDatabase();
            quorumPeer.setCnxnFactory(cnxnFactory);
            quorumPeer.setSecureCnxnFactory(secureCnxnFactory);
            quorumPeer.setSslQuorum(config.isSslQuorum());
            quorumPeer.setUsePortUnification(config.shouldUsePortUnification());
            quorumPeer.setLearnerType(config.getPeerType());
            quorumPeer.setSyncEnabled(config.getSyncEnabled());
            //投票决定方式，默认超过半数就通过
            quorumPeer.setQuorumListenOnAllIPs(config.getQuorumListenOnAllIPs());
            if (config.sslQuorumReloadCertFiles) {
                quorumPeer.getX509Util().enableCertFileReloading();
            }
            quorumPeer.setMultiAddressEnabled(config.isMultiAddressEnabled());
            quorumPeer.setMultiAddressReachabilityCheckEnabled(config.isMultiAddressReachabilityCheckEnabled());
            quorumPeer.setMultiAddressReachabilityCheckTimeoutMs(config.getMultiAddressReachabilityCheckTimeoutMs());

            // sets quorum sasl authentication configurations
            quorumPeer.setQuorumSaslEnabled(config.quorumEnableSasl);
            if (quorumPeer.isQuorumSaslAuthEnabled()) {
                quorumPeer.setQuorumServerSaslRequired(config.quorumServerRequireSasl);
                quorumPeer.setQuorumLearnerSaslRequired(config.quorumLearnerRequireSasl);
                quorumPeer.setQuorumServicePrincipal(config.quorumServicePrincipal);
                quorumPeer.setQuorumServerLoginContext(config.quorumServerLoginContext);
                quorumPeer.setQuorumLearnerLoginContext(config.quorumLearnerLoginContext);
            }
            quorumPeer.setQuorumCnxnThreadsSize(config.quorumCnxnThreadsSize);
            quorumPeer.initialize();

            if (config.jvmPauseMonitorToRun) {
                quorumPeer.setJvmPauseMonitor(new JvmPauseMonitor(config));
            }
            /**
             * 启动主线程，run()就是核心无疑
             */
            quorumPeer.start();
            ZKAuditProvider.addZKStartStopAuditLog();
            quorumPeer.join();
        } catch (InterruptedException e) {
            // warn, but generally this is ok
            LOG.warn("Quorum Peer interrupted", e);
        } finally {
            try {
                metricsProvider.stop();
            } catch (Throwable error) {
                LOG.warn("Error while stopping metrics", error);
            }
        }
    }

4，QuorumPeer.start()

QuorumPeer.start 方法，重写了 Thread 的 start。也就是在线程启动之前，会做以下操作

1. 通过 loadDataBase 恢复快照数据

2. cnxnFactory.start() 启动 zkServer，相当于用户可以通过 2181 这个端口进行通信了

    @Override
    public synchronized void start() {
        if (!getView().containsKey(myid)) {
            throw new RuntimeException("My id " + myid + " not in the peer list");
        }
        //恢复数据快照
        loadDataBase();

        startServerCnxnFactory();
        try {
            //启动zk server
            adminServer.start();
        } catch (AdminServerException e) {
            LOG.warn("Problem starting AdminServer", e);
            System.out.println(e);
        }
        //选举
        startLeaderElection();
        startJvmPauseMonitor();
        super.start();
    }

5,startLeaderElection()

    public synchronized void startLeaderElection() {
        try {
            if (getPeerState() == ServerState.LOOKING) {
                //构建一个票据，用于投票
                currentVote = new Vote(myid, getLastLoggedZxid(), getCurrentEpoch());
            }
        } catch (IOException e) {
            RuntimeException re = new RuntimeException(e.getMessage());
            re.setStackTrace(e.getStackTrace());
            throw re;
        }
        //创建选举算法
        this.electionAlg = createElectionAlgorithm(electionType);
    }

6,createElectionAlgorithm()

根据对应的标识创建选举算法

    protected Election createElectionAlgorithm(int electionAlgorithm) {
        Election le = null;

        //TODO: use a factory rather than a switch
        switch (electionAlgorithm) {
        case 1:
            throw new UnsupportedOperationException("Election Algorithm 1 is not supported.");
        case 2:
            throw new UnsupportedOperationException("Election Algorithm 2 is not supported.");
        case 3:
            QuorumCnxManager qcm = createCnxnManager();
            QuorumCnxManager oldQcm = qcmRef.getAndSet(qcm);
            if (oldQcm != null) {
                LOG.warn("Clobbering already-set QuorumCnxManager (restarting leader election?)");
                oldQcm.halt();
            }
            QuorumCnxManager.Listener listener = qcm.listener;
            if (listener != null) {
                //启动监听器
                listener.start();
                //初始化 FastLeaderElection
                FastLeaderElection fle = new FastLeaderElection(this, qcm);
                fle.start();
                le = fle;
            } else {
                LOG.error("Null listener when initializing cnx manager");
            }
            break;
        default:
            assert false;
        }
        return le;
    }

7,FastLeaderElection

初始化FastLeaderElection，QuorumCnxManager是一个很核心的对象，用来实现领导选举中的网络连接管理功能

    public FastLeaderElection(QuorumPeer self, QuorumCnxManager manager) {
        this.stop = false;
        this.manager = manager;
        starter(self, manager);
    }

8,starter()

starter 方法里面，设置了一些成员属性，并且构建了两个阻塞队列，分别是 sendQueue 和 recvqueue。并且实例化了一个 Messager.

    private void starter(QuorumPeer self, QuorumCnxManager manager) {
        this.self = self;
        proposedLeader = -1;
        proposedZxid = -1;

        sendqueue = new LinkedBlockingQueue<ToSend>();
        recvqueue = new LinkedBlockingQueue<Notification>();
        this.messenger = new Messenger(manager);
    }

9,Messenger

在 Messenger 里面构建了两个线程，一个是 WorkerSender，一个是WorkerReceiver。 这两个线程是分别用来发送和接收消息的线程。

        Messenger(QuorumCnxManager manager) {

            this.ws = new WorkerSender(manager);

            this.wsThread = new Thread(this.ws, "WorkerSender[myid=" + self.getId() + "]");
            this.wsThread.setDaemon(true);

            this.wr = new WorkerReceiver(manager);

            this.wrThread = new Thread(this.wr, "WorkerReceiver[myid=" + self.getId() + "]");
            this.wrThread.setDaemon(true);
        }

10,阶段性总结

四，getView 的解析流程

getView 里面实际上返回的是一个 quorumPeers，就是参与本次投票的成员有哪些。

    public Map<Long, QuorumPeer.QuorumServer> getView() {
        return Collections.unmodifiableMap(getQuorumVerifier().getAllMembers());
    }

五，ZkServer 服务启动的逻辑

leader 选举的时候，有一个 cnxnFactory.start()方法来启动 zk 服务，这块具体做了什么呢？

1，QuorumPeerMain.runFromConfig()

在 runFromConfig 中，构建了一个 ServerCnxnFactory

            if (config.getClientPortAddress() != null) {
                cnxnFactory = ServerCnxnFactory.createFactory();
                cnxnFactory.configure(config.getClientPortAddress(), config.getMaxClientCnxns(), config.getClientPortListenBacklog(), false);
            }

            if (config.getSecureClientPortAddress() != null) {
                secureCnxnFactory = ServerCnxnFactory.createFactory();
                secureCnxnFactory.configure(config.getSecureClientPortAddress(), config.getMaxClientCnxns(), config.getClientPortListenBacklog(), true);
            }
//并且将这个 factory 设置给了 quorumPeer 的成员属性
quorumPeer.setCnxnFactory(cnxnFactory);

这个很明显是一个工厂模式，基于这个工厂类创建什么呢？

2，createFactory()

这个方法里面是根据 ZOOKEEPER_SERVER_CNXN_FACTORY 来决定创建 NIO server 还是 Netty Server

默认情况下，应该是创建一个 NIOServerCnxnFactory

public static ServerCnxnFactory createFactory() throws IOException {
    String serverCnxnFactoryName = System.getProperty(ZOOKEEPER_SERVER_CNXN_FACTORY);
    if (serverCnxnFactoryName == null) {
        serverCnxnFactoryName = NIOServerCnxnFactory.class.getName();
    }
    try {
        ServerCnxnFactory serverCnxnFactory = (ServerCnxnFactory) Class.forName(serverCnxnFactoryName)
                                                                       .getDeclaredConstructor()
                                                                       .newInstance();
        LOG.info("Using {} as server connection factory", serverCnxnFactoryName);
        return serverCnxnFactory;
    } catch (Exception e) {
        IOException ioe = new IOException("Couldn't instantiate " + serverCnxnFactoryName, e);
        throw ioe;
    }
}

3，QuorumPeer.start()

回到 QuorumPeer.start()方法中，cnxnFactory.start()，应该会调用 NIOServerCnxnFactory 这个类去启动一个线程

private void startServerCnxnFactory() {
    if (cnxnFactory != null) {
        cnxnFactory.start();
    }
    if (secureCnxnFactory != null) {
        secureCnxnFactory.start();
    }
}

4，NIOServerCnxnFactory.start()

这里通过 thread.start 启动一个线程

    @Override
    public void start() {
        stopped = false;
        if (workerPool == null) {
            workerPool = new WorkerService("NIOWorker", numWorkerThreads, false);
        }
        for (SelectorThread thread : selectorThreads) {
            if (thread.getState() == Thread.State.NEW) {
                thread.start();
            }
        }
        // ensure thread is started once and only once
        if (acceptThread.getState() == Thread.State.NEW) {
            acceptThread.start();
        }
        if (expirerThread.getState() == Thread.State.NEW) {
            expirerThread.start();
        }
    }

5，NIOServerCnxnFactory.configure（）

thread 其实构建的是一个 zookeeperThread 线程，并且线程的参数为 this，表示当前 NIOServerCnxnFactory 也是实现了线程的类，那么它必须要重写run 方法，因此定位到 NIOServerCnxnFactory.run。到此，NIOServer 的初始化以及启动过程就完成了。并且对 2181 的这个端口进行监听。一旦发现有请求进来，就执行相应的处理即可。

    @Override
    public void configure(InetSocketAddress addr, int maxcc, int backlog, boolean secure) throws IOException {
        if (secure) {
            throw new UnsupportedOperationException("SSL isn't supported in NIOServerCnxn");
        }
        configureSaslLogin();

        maxClientCnxns = maxcc;
        initMaxCnxns();
        sessionlessCnxnTimeout = Integer.getInteger(ZOOKEEPER_NIO_SESSIONLESS_CNXN_TIMEOUT, 10000);
        
        cnxnExpiryQueue = new ExpiryQueue<NIOServerCnxn>(sessionlessCnxnTimeout);
        expirerThread = new ConnectionExpirerThread();

        int numCores = Runtime.getRuntime().availableProcessors();
        
        numSelectorThreads = Integer.getInteger(
            ZOOKEEPER_NIO_NUM_SELECTOR_THREADS,
            Math.max((int) Math.sqrt((float) numCores / 2), 1));
        if (numSelectorThreads < 1) {
            throw new IOException("numSelectorThreads must be at least 1");
        }

        numWorkerThreads = Integer.getInteger(ZOOKEEPER_NIO_NUM_WORKER_THREADS, 2 * numCores);
        workerShutdownTimeoutMS = Long.getLong(ZOOKEEPER_NIO_SHUTDOWN_TIMEOUT, 5000);

        String logMsg = "Configuring NIO connection handler with "
            + (sessionlessCnxnTimeout / 1000) + "s sessionless connection timeout, "
            + numSelectorThreads + " selector thread(s), "
            + (numWorkerThreads > 0 ? numWorkerThreads : "no") + " worker threads, and "
            + (directBufferBytes == 0 ? "gathered writes." : ("" + (directBufferBytes / 1024) + " kB direct buffers."));
        LOG.info(logMsg);
        for (int i = 0; i < numSelectorThreads; ++i) {
            selectorThreads.add(new SelectorThread(i));
        }

        listenBacklog = backlog;
        this.ss = ServerSocketChannel.open();
        ss.socket().setReuseAddress(true);
        LOG.info("binding to port {}", addr);
        if (listenBacklog == -1) {
            ss.socket().bind(addr);
        } else {
            ss.socket().bind(addr, listenBacklog);
        }
        ss.configureBlocking(false);
        acceptThread = new AcceptThread(ss, addr, selectorThreads);
    }

六，选举流程分析

正式分析 leader 选举的过程

public synchronized void start() {
    loadDataBase();
    cnxnFactory.start();
    startLeaderElection();
    super.start(); //启动线程
}

很明显，super.start() 表示当前类 QuorumPeer 继承了线程，线程必须要重写 run 方法，所以我们可以在 QuorumPeer 中找到一个 run 方法

1，QuorumPeer.run()

PeerState 有几种状态，分别是：

1. LOOKING，竞选状态。
2. FOLLOWING，随从状态，同步 leader 状态，参与投票。
3. OBSERVING，观察状态,同步 leader 状态，不参与投票。
4. LEADING，领导者状态。

对于选举来说，默认都是 LOOKING 状态，只有 LOOKING 状态才会去执行选举算法。每个服务器在启动时都会选择自己做为领导，然后将投票信息发送出去，循环一直到选举出领导为止。

            //根据选举状态，选择不同的处理方式
            while (running) {
                if (unavailableStartTime == 0) {
                    unavailableStartTime = Time.currentElapsedTime();
                }

                switch (getPeerState()) {
                case LOOKING:
                    LOG.info("LOOKING");
                    ServerMetrics.getMetrics().LOOKING_COUNT.add(1);
                    //判断是否为只读模式,通过”readonlymode.enabled”开启
                    if (Boolean.getBoolean("readonlymode.enabled")) {
                        LOG.info("Attempting to start ReadOnlyZooKeeperServer");

                        // Create read-only server but don't start it immediately
                        final ReadOnlyZooKeeperServer roZk = new ReadOnlyZooKeeperServer(logFactory, this, this.zkDb);

                        //只读模式的启动流程
                        Thread roZkMgr = new Thread() {
                            public void run() {
                                try {
                                    // lower-bound grace period to 2 secs
                                    sleep(Math.max(2000, tickTime));
                                    if (ServerState.LOOKING.equals(getPeerState())) {
                                        roZk.startup();
                                    }
                                } catch (InterruptedException e) {
                                    LOG.info("Interrupted while attempting to start ReadOnlyZooKeeperServer, not started");
                                } catch (Exception e) {
                                    LOG.error("FAILED to start ReadOnlyZooKeeperServer", e);
                                }
                            }
                        };
                        try {
                            roZkMgr.start();
                            reconfigFlagClear();
                            if (shuttingDownLE) {
                                shuttingDownLE = false;
                                startLeaderElection();
                            }
                            setCurrentVote(makeLEStrategy().lookForLeader());
                        } catch (Exception e) {
                            LOG.warn("Unexpected exception", e);
                            setPeerState(ServerState.LOOKING);
                        } finally {
                            // If the thread is in the the grace period, interrupt
                            // to come out of waiting.
                            roZkMgr.interrupt();
                            roZk.shutdown();
                        }
                    } else {
                        try {
                            reconfigFlagClear();
                            if (shuttingDownLE) {
                                shuttingDownLE = false;
                                startLeaderElection();
                            }
                            //设置当前的投票，通过策略模式来决定当前用哪个选举算法来进行领导选举
                            setCurrentVote(makeLEStrategy().lookForLeader());

2，FastLeaderElection.lookForLeader()

开始发起投票流程

public Vote lookForLeader() throws InterruptedException {
        try {
            self.jmxLeaderElectionBean = new LeaderElectionBean();
            MBeanRegistry.getInstance().register(self.jmxLeaderElectionBean, self.jmxLocalPeerBean);
        } catch (Exception e) {
            LOG.warn("Failed to register with JMX", e);
            self.jmxLeaderElectionBean = null;
        }

        self.start_fle = Time.currentElapsedTime();
        try {

            Map<Long, Vote> recvset = new HashMap<Long, Vote>();


            Map<Long, Vote> outofelection = new HashMap<Long, Vote>();

            int notTimeout = minNotificationInterval;

            synchronized (this) {
                //更新逻辑时钟，用来判断是否在同一轮选举周期
                logicalclock.incrementAndGet();
                //初始化选票数据：这里其实就是把当前节点的 myid，zxid,epoch 更新到本地的成员属性
                updateProposal(getInitId(), getInitLastLoggedZxid(), getPeerEpoch());
            }
            //异步发送选举信息
            sendNotifications();

            SyncedLearnerTracker voteSet = null;
            // 这里就是不断循环，根据投票信息进行进行 leader 选举
            while ((self.getPeerState() == ServerState.LOOKING) && (!stop)) {
                // 从 recvqueue 中获取消息
                Notification n = recvqueue.poll(notTimeout, TimeUnit.MILLISECONDS);

                //如果没有获取到外部的投票，有可能是集群之间的节点没有真正连接上
                if (n == null) {
                    //判断发送队列是否有数据，如果发送队列为空，再发一次自己的选票
                    if (manager.haveDelivered()) {
                        sendNotifications();
                    } else {//在此发起集群节点之间的连接
                        manager.connectAll();
                    }

                    int tmpTimeOut = notTimeout * 2;
                    notTimeout = Math.min(tmpTimeOut, maxNotificationInterval);

                    self.getQuorumVerifier().revalidateVoteset(voteSet, notTimeout != minNotificationInterval);
                    if (self.getQuorumVerifier() instanceof QuorumOracleMaj && voteSet != null && voteSet.hasAllQuorums() && notTimeout != minNotificationInterval) {
                        setPeerState(proposedLeader, voteSet);
                        Vote endVote = new Vote(proposedLeader, proposedZxid, logicalclock.get(), proposedEpoch);
                        leaveInstance(endVote);
                        return endVote;
                    }


                }
                /**
                 * 选票的判断逻辑 --- 竞选的核心
                 */
                // 判断收到的选票中的 sid  和选举的 leader 的 的 sid  是否存在于我们的 集群所配置的 myid
                else if (validVoter(n.sid) && validVoter(n.leader)) {
                    //判断接收到的投票者的状态，默认是 LOOKING 状态,说明当前发起投票的服务器也是在找 leader
                    switch (n.state) {
                    case LOOKING://说明当前发起投票的服务器也是在找 leader
                        if (getInitLastLoggedZxid() == -1) {
                            break;
                        }
                        if (n.zxid == -1) {
                            break;
                        }
                          如果收到的投票的逻辑时钟大于当前的节点的逻辑时钟
                        if (n.electionEpoch > logicalclock.get()) {
                            //更新成新一轮的逻辑时钟
                            logicalclock.set(n.electionEpoch);
                            recvset.clear();
                            //比较接收到的投票和当前节点的信息
                            //比较的顺序:epoch、zxid、myid,如果返回 true，则更新当前节点的票据（sid,zxid,epoch）,
                            //那么下次再发起投票的时候，就不再是选自己了
                            if (totalOrderPredicate(n.leader, n.zxid, n.peerEpoch, getInitId(), getInitLastLoggedZxid(), getPeerEpoch())) {
                                updateProposal(n.leader, n.zxid, n.peerEpoch);
                            } else {//否则，说明当前节点的票据优先级更高，再次更新自己的票据
                                updateProposal(getInitId(), getInitLastLoggedZxid(), getPeerEpoch());
                            }
                            //再次发送消息把当前的票据发出去
                            sendNotifications();

                        } else if (n.electionEpoch < logicalclock.get()) {
                            //如果小于，说明收到的票据已经过期了，直接把这张票丢掉

                            break;
                        } else if (totalOrderPredicate(n.leader, n.zxid, n.peerEpoch, proposedLeader, proposedZxid, proposedEpoch)) {
                            //这个判断表示收到的票据的 epoch 是相同的，那么按照 epoch、zxid、myid 顺序进行比较
                            //比较成功以后，把对方的票据信息更新到自己的节点
                            updateProposal(n.leader, n.zxid, n.peerEpoch);
                            //把收到的票据再发出去，告诉大家我要选 n.leader 为 leader
                            sendNotifications();
                        }
                        //将收到的投票信息放入投票的集合 recvset 中, 用来作为最终的 "过半原则" 判断
                        recvset.put(n.sid, new Vote(n.leader, n.zxid, n.electionEpoch, n.peerEpoch));

                        voteSet = getVoteTracker(recvset, new Vote(proposedLeader, proposedZxid, logicalclock.get(), proposedEpoch));

                        if (voteSet.hasAllQuorums()) {
                            //进入这个判断，说明选票达到了 leader 选举的要求
                            // 在更新状态之前，服务器会等待 finalizeWait  毫秒
                            //时间来接收新的选票，以防止漏下关键选票。
                            //如果收到可能改变 Leader  的新选票，则重新进行计票
                            while ((n = recvqueue.poll(finalizeWait, TimeUnit.MILLISECONDS)) != null) {

                                if (totalOrderPredicate(n.leader, n.zxid, n.peerEpoch, proposedLeader, proposedZxid, proposedEpoch)) {
                                    recvqueue.put(n);
                                    break;
                                }
                            }
                            // 如果 notifaction 为空，说明 Leader 节点是可以确定好了
                            if (n == null) {
                                /*
                                设置当前当前节点的状态（判断 leader 节点是不是我自己，如果是，直接更新当前节点的 state 为 LEADING）
                                否则，根据当前节点的特性进行判断，决定是FOLLOWING 还是 OBSERVING
                                 */
                                setPeerState(proposedLeader, voteSet);
                                //组装生成这次 Leader 选举最终的投票的结果
                                Vote endVote = new Vote(proposedLeader, proposedZxid, logicalclock.get(), proposedEpoch);
                                // 清空recvqueue
                                leaveInstance(endVote);
                                //返回最终的票据
                                return endVote;
                            }
                        }
                        break;
                    case OBSERVING://OBSERVING 不参与 leader 选举
                        break;

                    case FOLLOWING:

                        Vote resultFN = receivedFollowingNotification(recvset, outofelection, voteSet, n);
                        if (resultFN == null) {
                            break;
                        } else {
                            return resultFN;
                        }
                    case LEADING:

                        Vote resultLN = receivedLeadingNotification(recvset, outofelection, voteSet, n);
                        if (resultLN == null) {
                            break;
                        } else {
                            return resultLN;
                        }
                    default:
                        break;
                    }
                } else {
                    if (!validVoter(n.leader)) {

                    }
                    if (!validVoter(n.sid)) {

                    }
                }
            }
            return null;
        } finally {
            try {
                if (self.jmxLeaderElectionBean != null) {
                    MBeanRegistry.getInstance().unregister(self.jmxLeaderElectionBean);
                }
            } catch (Exception e) {

            }
            self.jmxLeaderElectionBean = null;
        }
    }

3，投票处理的流程图

七，投票的网络通信流程

1，通信流程图

2，接收数据 Notification 和发送 ToSend

ToSender

leader； 被推荐的服务器 sid

zxid; 被推荐的服务器当前最新的事务 id

peerEpoch; 被推荐的服务器当前所处的 epoch

electionepoch； 当前服务器所处的 epoch

stat 当前服务器状态

sid 接收消息的服务器 sid（myid）

Notification

leader； //被推荐的服务器 sid

zxid； 被推荐的服务器最新事务 id

peerEpoch; 被推荐的服务器当前所处的 epoch

electionEpoch 选举服务器所处的 epoch

stat； 选举服务器当前的状态

sid； 选举服务器的 sid

3，通信过程源码分析

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

protected Election createElectionAlgorithm(int electionAlgorithm) {
	        case 3:
            QuorumCnxManager qcm = createCnxnManager();
            QuorumCnxManager oldQcm = qcmRef.getAndSet(qcm);
            if (oldQcm != null) {
                LOG.warn("Clobbering already-set QuorumCnxManager (restarting leader election?)");
                oldQcm.halt();
            }
            QuorumCnxManager.Listener listener = qcm.listener;
            if (listener != null) {
                //启动监听器
                listener.start();
                //初始化 FastLeaderElection
                FastLeaderElection fle = new FastLeaderElection(this, qcm);
                fle.start();
                le = fle;
            } else {
                LOG.error("Null listener when initializing cnx manager");
            }
            break;
  }

listener 实现了线程，所以在 run 方法中可以看到构建ServerSocket 的请求，这里专门用来接收其他zkServer 的投票请求

        @Override
        public void run() {
            if (!shutdown) {
                Set<InetSocketAddress> addresses;

                if (self.getQuorumListenOnAllIPs()) {
                    addresses = self.getElectionAddress().getWildcardAddresses();
                } else {
                    addresses = self.getElectionAddress().getAllAddresses();
                }

                CountDownLatch latch = new CountDownLatch(addresses.size());
                listenerHandlers = addresses.stream().map(address ->
                                new ListenerHandler(address, self.shouldUsePortUnification(), self.isSslQuorum(), latch))
                        .collect(Collectors.toList());

                ExecutorService executor = Executors.newFixedThreadPool(addresses.size());
                listenerHandlers.forEach(executor::submit);

                try {
                    latch.await();
                } catch (InterruptedException ie) {
                    
                } finally {
                    // Clean up for shutdown.
                    for (ListenerHandler handler : listenerHandlers) {
                        try {
                            handler.close();
                        } catch (IOException ie) {
                        }
                    }
                }
            }
            
            if (!shutdown) {
                if (socketException.get()) {
                    socketBindErrorHandler.run();
                }
            }
        }

2)FastLeaderElection.lookForLeader()

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

public Vote lookForLeader() throws InterruptedException {
    //这个方法，会把当前zk 服务器的信息添加到 sendqueue
    sendNotifications();
}

3)FastLeaderElection.sendqueue()

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

class WorkerSender extends ZooKeeperThread {

    volatile boolean stop;
    QuorumCnxManager manager;

    WorkerSender(QuorumCnxManager manager) {
        super("WorkerSender");
        this.stop = false;
        this.manager = manager;
    }

    public void run() {
        while (!stop) {
            try {
                //从队列中获取 ToSend 对象
                ToSend m = sendqueue.poll(3000, TimeUnit.MILLISECONDS);
                if (m == null) {
                    continue;
                }

                process(m);
            } catch (InterruptedException e) {
                break;
            }
        }
        LOG.info("WorkerSender is down");
    }

    void process(ToSend m) {
        ByteBuffer requestBuffer = buildMsg(m.state.ordinal(), m.leader, m.zxid, m.electionEpoch, m.peerEpoch, m.configData);
        //这里就是调用 QuorumCnxManager 进行消息发送
        manager.toSend(m.sid, requestBuffer);

    }

}

4)QuorumCnxManager.toSend()

    public void toSend(Long sid, ByteBuffer b) {

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

5)startConnection()

//为了防止重复建立连接，只允许 sid 大的主动连接 sid 小的
if (sid > self.getId()) {
    LOG.info("Have smaller server identifier, so dropping the connection: (myId:{} --> sid:{})", self.getId(), sid);
    closeSocket(sock);
    //构建一个发送线程和接收线程,负责针对当前连接的数据传递
} else {
    LOG.debug("Have larger server identifier, so keeping the connection: (myId:{} --> sid:{})", self.getId(), sid);
    SendWorker sw = new SendWorker(sock, sid);
    RecvWorker rw = new RecvWorker(sock, din, sid, sw);
    sw.setRecv(rw);

    SendWorker vsw = senderWorkerMap.get(sid);

    if (vsw != null) {
        vsw.finish();
    }

    senderWorkerMap.put(sid, sw);

    queueSendMap.putIfAbsent(sid, new CircularBlockingQueue<>(SEND_CAPACITY));

    sw.start();
    rw.start();

    return true;

}

SendWorker 会监听对应 sid 的阻塞队列，启动的时候回如果队列为空时会重新发送一次最前最后的消息，以防上一次处理是服务器异常退出，造成上一条消息未处理成功；然后就是不停监听队里，发现有消息时调用send 方法。

RecvWorker ： RecvWorker 不停监听 socket 的 inputstream，读取消息放到消息接收队列中,消息放入队列中，qcm 的流程就完毕了。

6)QuorumCnxManager.Listener

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

        @Override
        public void run() {
        	if (!shutdown) {
                if (socketException.get()) {
                    socketBindErrorHandler.run();
                }
            }
        }

7)ListenerHandler.run()

            @Override
            public void run() {
                try {
                    Thread.currentThread().setName("ListenerHandler-" + address);
                    acceptConnections();
                    try {
                        close();
                    } catch (IOException e) {
                        LOG.warn("Exception when shutting down listener: ", e);
                    }
                } catch (Exception e) {
                    // Output of unexpected exception, should never happen
                    LOG.error("Unexpected error ", e);
                } finally {
                    latch.countDown();
                }
            }

8)acceptConnections()

private void acceptConnections() {
    int numRetries = 0;
    Socket client = null;

    while ((!shutdown) && (portBindMaxRetry == 0 || numRetries < portBindMaxRetry)) {
        try {
            serverSocket = createNewServerSocket();
            while (!shutdown) {
                try {
                    client = serverSocket.accept();
                    setSockOpts(client);
                    
                    if (quorumSaslAuthEnabled) {
                        receiveConnectionAsync(client);
                    } else {
                        receiveConnection(client);
                    }
                    numRetries = 0;
                } catch (SocketTimeoutException e) {

                }
            }
        } catch (IOException e) {
            if (shutdown) {
                break;
            }
            

            if (e instanceof SocketException) {
                socketException.set(true);
            }

            numRetries++;
            try {
                close();
                Thread.sleep(1000);
            } catch (IOException ie) {
                
            } catch (InterruptedException ie) {
               
            }
            closeSocket(client);
        }
    }
    if (!shutdown) {
    }
}

9)receiveConnection()

public void receiveConnection(final Socket sock) {
    DataInputStream din = null;
    try {
        din = new DataInputStream(new BufferedInputStream(sock.getInputStream()));
        handleConnection(sock, din);
    } catch (IOException e) {
        closeSocket(sock);
    }
}

10)handleConnection()

private void handleConnection(Socket sock, DataInputStream din) throws IOException {
    Long sid = null, protocolVersion = null;
    MultipleAddresses electionAddr = null;

    try {
        protocolVersion = din.readLong();
        if (protocolVersion >= 0) {
            // 获取客户端的 sid ，也就是 myid
            sid = protocolVersion;
        } else {
            try {
                InitialMessage init = InitialMessage.parse(protocolVersion, din);
                sid = init.sid;
                if (!init.electionAddr.isEmpty()) {
                    electionAddr = new MultipleAddresses(init.electionAddr,
                            Duration.ofMillis(self.getMultiAddressReachabilityCheckTimeoutMs()));
                }
                LOG.debug("Initial message parsed by {}: {}", self.getId(), init.toString());
            } catch (InitialMessage.InitialMessageException ex) {
                LOG.error("Initial message parsing error!", ex);
                closeSocket(sock);
                return;
            }
        }

        if (sid == QuorumPeer.OBSERVER_ID) {
            sid = observerCounter.getAndDecrement();
            LOG.info("Setting arbitrary identifier to observer: {}", sid);
        }
    } catch (IOException e) {
        LOG.warn("Exception reading or writing challenge", e);
        closeSocket(sock);
        return;
    }


    authServer.authenticate(sock, din);
    ///为了防止重复建立连接，只允许 sid 大的主动连接 sid 小的
    if (sid < self.getId()) {

        SendWorker sw = senderWorkerMap.get(sid);
        if (sw != null) {
            sw.finish();
        }

        closeSocket(sock);//关闭连接

        if (electionAddr != null) {
            //向 sid 发起连接
            connectOne(sid, electionAddr);
        } else {
            connectOne(sid);
        }

    } else if (sid == self.getId()) {

    } else {
        //同样，构建一个 SendWorker 和RecvWorker 进行发送和接收数据
        SendWorker sw = new SendWorker(sock, sid);
        RecvWorker rw = new RecvWorker(sock, din, sid, sw);
        sw.setRecv(rw);

        SendWorker vsw = senderWorkerMap.get(sid);

        if (vsw != null) {
            vsw.finish();
        }

        senderWorkerMap.put(sid, sw);

        queueSendMap.putIfAbsent(sid, new CircularBlockingQueue<>(SEND_CAPACITY));

        sw.start();
        rw.start();
    }
}

八，leader 选举完成之后的处理逻辑

通过 lookForLeader 方法选举完成以后，会设置当前节点的 PeerState，要么为 Leading、要么就是 FOLLOWING、或者 OBSERVING，到这里，只是表示当前的 leader 选出来了，但是 QuorumPeer.run 方法里面还没执行完。

1，makeFollower()

初始化一个 Follower 对象

构建一个 FollowerZookeeperServer，表示 follower 节点的请求处理服务

    protected Follower makeFollower(FileTxnSnapLog logFactory) throws IOException {
        return new Follower(this, new FollowerZooKeeperServer(logFactory, this, this.zkDb));
    }

2,followLeader()

try {
    self.setZabState(QuorumPeer.ZabState.DISCOVERY);
    //根据 sid 找到对应 leader，拿到 lead 连接信息
    QuorumServer leaderServer = findLeader();
    try {
        //连接到 Leader
        connectToLeader(leaderServer.addr, leaderServer.hostname);
        connectionTime = System.currentTimeMillis();
        //将 Follower 的 zxid 及 myid 等信息封装好发送到 Leader，同步 epoch。
        //也就是意味着接下来 follower 节点只同步新epoch 的数据信息
        long newEpochZxid = registerWithLeader(Leader.FOLLOWERINFO);
        if (self.isReconfigStateChange()) {
            throw new Exception("learned about role change");
        }
        //如果 leader 的 epoch 比当前 follow 节点的poch 还小，抛异常
        long newEpoch = ZxidUtils.getEpochFromZxid(newEpochZxid);
        if (newEpoch < self.getAcceptedEpoch()) {

            throw new IOException("Error: Epoch of leader is lower");
        }
        long startTime = Time.currentElapsedTime();
        try {
            self.setLeaderAddressAndId(leaderServer.addr, leaderServer.getId());
            self.setZabState(QuorumPeer.ZabState.SYNCHRONIZATION);
            //和 leader 进行数据同步
            syncWithLeader(newEpochZxid);
            self.setZabState(QuorumPeer.ZabState.BROADCAST);
            completedSync = true;
        } finally {
            long syncTime = Time.currentElapsedTime() - startTime;
            ServerMetrics.getMetrics().FOLLOWER_SYNC_TIME.add(syncTime);
        }
        if (self.getObserverMasterPort() > 0) {
            LOG.info("Starting ObserverMaster");

            om = new ObserverMaster(self, fzk, self.getObserverMasterPort());
            om.start();
        } else {
            om = null;
        }
        // create a reusable packet to reduce gc impact
        QuorumPacket qp = new QuorumPacket();
        while (this.isRunning()) {//接受 Leader消息，执行并反馈给 leader，线程在此自旋
            readPacket(qp);//从 leader 读取数据包
            processPacket(qp);//处理 packet
        }
    } catch (Exception e) {
        LOG.warn("Exception when following the leader", e);
        closeSocket();

        // clear pending revalidations
        pendingRevalidations.clear();
    }
}

3,makeLeader()

初始化一个 Leader 对象，构建一个 LeaderZookeeperServer，用于表示leader 节点的请求处理服务

    protected Leader makeLeader(FileTxnSnapLog logFactory) throws IOException, X509Exception {
        return new Leader(this, new LeaderZooKeeperServer(logFactory, this, this.zkDb));
    }

4,leader.lead()

在 Leader 端, 则通过 lead()来处理与 Follower 的交互