1. Zookeeper 选举机制概述

SID：服务器ID。用来唯一标识一台ZooKeeper集群中的机器，每台机器不能重复，和myid一致。
ZXID：事务ID。ZXID是一个事务ID，用来标识一次服务器状态的变更。在某一时刻，集群中的每台机器的ZXID值不一定完全一致，这和ZooKeeper服务器对于客户端"更新请求"的处理逻辑有关。
Epoch：每个Leader任期的代号。没有Leader时同一轮投票过程中的逻辑时钟值是相同的。每投完一次票这个数据就会增加

1.1. Zookeeper 选举机制

当第一次启动时，Zookeeper的选举机制如下图：

（1）服务器1启动，发起一次选举。服务器1投自己一票。此时服务器1票数一票，不够半数以上（3票），选举无法完成，服务器1状态保持为LOOKING；

（2）服务器2启动，再发起一次选举。服务器1和2分别投自己一票并交换选票信息：此时服务器1发现服务器2的myid比自己目前投票推举的（服务器1）大，更改选票为推举服务器2。此时服务器1票数0票，服务器2票数2票，没有半数以上结果，选举无法完成，服务器1，2状态保持LOOKING

（3）服务器3启动，发起一次选举。此时服务器1和2都会更改选票为服务器3。此次投票结果：服务器1为0票，服务器2为0票，服务器3为3票。此时服务器3的票数已经超过半数，服务器3当选Leader。服务器1，2更改状态为FOLLOWING，服务器3更改状态为LEADING；

（4）服务器4启动，发起一次选举。此时服务器1，2，3已经不是LOOKING状态，不会更改选票信息。交换选票信息结果：服务器3为3票，服务器4为1票。此时服务器4服从多数，更改选票信息为服务器3，并更改状态为FOLLOWING；

（5）服务器5启动，同4一样当小弟。

当非第一次启动时，选举过程如下所示：

（1）当ZooKeeper集群中的一台服务器出现以下两种情况之一时，就会开始进入Leader选举：

•服务器初始化启动。

•服务器运行期间无法和Leader保持连接。

（2）而当一台机器进入Leader选举流程时，当前集群也可能会处于以下两种状态：

•集群中本来就已经存在一个Leader。

对于第一种已经存在Leader的情况，机器试图去选举Leader时，会被告知当前服务器的Leader信息，对于该机器来说，仅仅需要和Leader机器建立连接，并进行状态同步即可。

•集群中确实不存在Leader。

假设ZooKeeper由5台服务器组成，SID分别为1、2、3、4、5，ZXID分别为8、8、8、7、7，并且此时SID为3的服务器是Leader。某一时刻，3和5服务器出现故障，因此开始进行Leader选举。

SID为1、2、4的机器投票情况：

（EPOCH，ZXID，SID）	（EPOCH，ZXID，SID）	（EPOCH，ZXID，SID）
（1，8，1）	（1，8，2）	（1，7，4）

1.2. Leader 选举规则

选举Leader规则：

EPOCH大的直接胜出
EPOCH相同，事务id大的胜出
事务id相同，服务器id大的胜出

1.3. 选举流程分析

2. 选举准备

2.1. 选举准备源码概览

2.2. QuorumPeer.java 源码

java 复制代码

public synchronized void start() {
    if (!getView().containsKey(myid)) {
        throw new RuntimeException("My id" + myid + " not in the peer list");
     }
    loadDataBase();
    startServerCnxnFactory();
    try {
        adminServer.start();
    } catch (AdminServerException e) {
        LOG.warn("Problem startingAdminServer", e);
        System.out.println(e);
    }
       // 选举准备
    startLeaderElection();
    super.start();
}
 
synchronized public void startLeaderElection() {
   try {
       if (getPeerState() ==ServerState.LOOKING) {
                //  创建选票
                // （1）选票组件：epoch（leader的任期代号）、zxid（某个leader当选期间执行的事务编号）、myid（serverid）
                // （2）开始选票时，都是先投自己
           currentVote = new Vote(myid,getLastLoggedZxid(), getCurrentEpoch());
       }
   } catch(IOException e) {
       RuntimeException re = newRuntimeException(e.getMessage());
       re.setStackTrace(e.getStackTrace());
       throw re;
   }
 
   // if (!getView().containsKey(myid)) {
  //     throw new RuntimeException("My id " + myid + " not in thepeer list");
    //}
    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);
}
 
protectedElection createElectionAlgorithm(intelectionAlgorithm){
    Election le=null;
 
    //TODO: use a factory rather than a switch
    switch (electionAlgorithm) {
    case 0:
        le = new LeaderElection(this);
        break;
    case 1:
        le = new AuthFastLeaderElection(this);
        break;
    case 2:
        le = new AuthFastLeaderElection(this,true);
        break;
    case 3:
              // 1创建QuorumCnxnManager，负责选举过程中的所有网络通信
        QuorumCnxManager qcm = createCnxnManager();
        QuorumCnxManager oldQcm =qcmRef.getAndSet(qcm);
             
        if (oldQcm != null) {
            LOG.warn("Clobberingalready-set QuorumCnxManager (restarting leader election?)");
            oldQcm.halt();
        }
        QuorumCnxManager.Listener listener = qcm.listener;
        if(listener != null){
                     // 2启动监听线程
            listener.start();
                    
                     // 3准备开始选举
            FastLeaderElection fle = new FastLeaderElection(this,qcm);
            fle.start();
            le = fle;
        } else {
            LOG.error("Null listener wheninitializing cnx manager");
        }
        break;
    default:
        assert false;
    }
    return le;
}

2.2.1. 网络通信组件初始化

kotlin 复制代码

public QuorumCnxManager createCnxnManager() {
    return new QuorumCnxManager(this,
            this.getId(),
            this.getView(),
            this.authServer,
            this.authLearner,
            this.tickTime * this.syncLimit,
            this.getQuorumListenOnAllIPs(),
            this.quorumCnxnThreadsSize,
            this.isQuorumSaslAuthEnabled());
}
 
public QuorumCnxManager(QuorumPeerself,
                        final long mySid,
                        Map<Long,QuorumPeer.QuorumServer> view,
                        QuorumAuthServer authServer,
                        QuorumAuthLearner authLearner,
                        int socketTimeout,
                        boolean listenOnAllIPs,
                        int quorumCnxnThreadsSize,
                        boolean quorumSaslAuthEnabled) {
       // 创建各种队列                              
    this.recvQueue= new ArrayBlockingQueue<Message>(RECV_CAPACITY);
    this.queueSendMap= new ConcurrentHashMap<Long,ArrayBlockingQueue<ByteBuffer>>();
    this.senderWorkerMap= new ConcurrentHashMap<Long,SendWorker>();
    this.lastMessageSent= new ConcurrentHashMap<Long,ByteBuffer>();
 
    String cnxToValue =System.getProperty("zookeeper.cnxTimeout");
    if(cnxToValue != null){
        this.cnxTO =Integer.parseInt(cnxToValue);
    }
 
    this.self = self;
 
    this.mySid = mySid;
    this.socketTimeout = socketTimeout;
    this.view = view;
    this.listenOnAllIPs = listenOnAllIPs;
 
    initializeAuth(mySid, authServer, authLearner,quorumCnxnThreadsSize,
            quorumSaslAuthEnabled);
 
    // Starts listener thread that waits forconnection requests
    listener = new Listener();
   listener.setName("QuorumPeerListener");
}

2.2.2. 监听线程初始化

点击QuorumCnxManager.Listener，找到对应的run方法

scss 复制代码

public void run() {
    int numRetries = 0;
    InetSocketAddress addr;
    Socket client = null;
    Exception exitException = null;
      
    while ((!shutdown) &&(portBindMaxRetry == 0 || numRetries < portBindMaxRetry)) {
        try {
            if(self.shouldUsePortUnification()) {
                LOG.info("CreatingTLS-enabled quorum server socket");
                ss = newUnifiedServerSocket(self.getX509Util(), true);
            } else if (self.isSslQuorum()) {
                LOG.info("CreatingTLS-only quorum server socket");
                ss = newUnifiedServerSocket(self.getX509Util(), false);
            } else {
                ss = new ServerSocket();
            }
 
            ss.setReuseAddress(true);
 
            if (self.getQuorumListenOnAllIPs()){
                int port =self.getElectionAddress().getPort();
                addr = newInetSocketAddress(port);
            } else {
                // Resolve hostname for thisserver in case the
                // underlying ip address haschanged.
               self.recreateSocketAddresses(self.getId());
                addr =self.getElectionAddress();
            }
            LOG.info("My election bindport: " + addr.toString());
            setName(addr.toString());
                     // 绑定服务器地址
            ss.bind(addr);
                     // 死循环
            while (!shutdown) {
                try {
                                   // 阻塞，等待处理请求
                    client = ss.accept();
                                  
                    setSockOpts(client);
                    LOG.info("Receivedconnection request "
                            +formatInetAddr((InetSocketAddress)client.getRemoteSocketAddress()));
                    // Receive and handle theconnection request
                    // asynchronously if thequorum sasl authentication is
                    // enabled. This isrequired because sasl server
                    // authentication processmay take few seconds to finish,
                    // this may delay next peer connectionrequests.
                    if (quorumSaslAuthEnabled){
                       receiveConnectionAsync(client);
                    } else {
                       receiveConnection(client);
                    }
                    numRetries = 0;
                } catch (SocketTimeoutExceptione) {
                    LOG.warn("The socketis listening for the election accepted "
                             + "and ittimed out unexpectedly, but will retry."
                             + "seeZOOKEEPER-2836");
                }
            }
        } catch (IOException e) {
            ... ...
            closeSocket(client);
        }
    }
    ... ..
.

}

2.2.3. 选举准备：点击点击FastLeaderElection

ini 复制代码

public FastLeaderElection(QuorumPeerself, QuorumCnxManager manager){
    this.stop = false;
    this.manager = manager;
 
    starter(self, manager);
}
 
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);
}

3. 选举执行

3.1. 选举执行源码概览

3.2. QuorumPeer.java