读书笔记：《从Paxos到Zookeeper 分布式一致性原理与实践》
选举的前提约定
- 观察者不参与选举，只有跟随者才参与选举。
- 优先选事务ID（ZXID）大的，事务Id相同再优先选服务器编号大的（myid或称sid）。
- 超过半数的相同投票，那这个投票对应的SID（myid）机器即为Leader。（>= n/2 + 1 ）
- 所有有效的投票都必须在同一个轮次中。
选举过程
术语
-
sid或者myid（服务器Id）
sid和myid可以等同，都是用来唯一标识一台Zookeeper集群中的机器，每台机器不能重复。回忆我们在安装Zookeeper集群的时候，会在
zoo.cfg文件中做如下简单配置：tickTime=2000
initLimit=10
syncLimit=5
dataDir=/opt/soft/zookeeper/data
clientPort=2181
server.1=master:2888:3888
server.2=slave1:2888:3888
server.3=slave2:2888:3888
注意，上面配置中有类似server.id=host:port:port的配置，这里的id就是Server Id，用来标识该机器在集群中的机器序号。同时，在每台Zookeeper机器上，我们都需要在数据目录（即上述配置中dataDir参数所指定的那个目录）下创建一个myid文件，该文件就只有一行内容，并且是一个数字，即对应每台机器的Server Id数字。
-
ZXID：事务ID
在Zookeeper中，事务是指能够改变Zookeeper服务器状态的操作，我们称之为事务操作或更新操作，一般包括数据节点创建与删除、数据节点内容更新和客户端会话创建与失效等操作。对于每一个事务请求，Zookeeper都会为其分配一个全局唯一递增的事务Id。从这些ZXID中也可以间接识别出Zookeeper处理这些更新操作请求的全局顺序。在某一个时刻，集群中每台机器的ZXID值不一定全都一致。
-
投票
Leader选举，顾名思义必须通过投票来实现。当集群中的机器发现自己无法检测到Leader机器的时候，就会开始尝试进行投票。
Quorum：过半机器数：
少数服从多数，过半投票，即当选。-
服务器状态：
Zookeeper集群中机器状态主要有：LOOKING、FOLLOWING、LEADING和OBSERVING 四种：- LOOKING：寻找Leader状态，当前集群中午Leader。
- FOLLOWING：跟随者状态，表明当前服务器角色是Follower。
- LEADING：领导者状态，表明当前服务器角色是Leader。
- OBSERVING：观察者状态，表明当前服务器角色是Observer。
具体的枚举状态可以参见源码（org.apache.zookeeper.server.quorum.QuorumPeer.ServerState）
``` java
public enum ServerState {
LOOKING, FOLLOWING, LEADING, OBSERVING;
}
```
产生选举动作的时机
Zookeeper集群中的每一台机器之间都通过心跳机制进行相互检测，一旦一台服务器出现以下两种情况之一，就会开始进入Leader选举：
- 服务器初始化启动。
- 服务器运行期间无法和leader保持连接。
而当一台机器进入Leader选举流程时，当前集群也可能会处于以下两种状态：
- 集群中本来就已经存在一个Leader。
- 集群中确实不存在Leader。
对于第一种已经存在Leader的情况，通常发生在集群中的某一台机器启动比较晚，在它启动之前，集群已经可以正常工作，即已经存在了一台Leader服务器。针对于这种情况，当该机器试图去选举Leader的时候，会被告知当前服务器的Leader的信息，对于该机器来说，仅仅需要和Leader机器建立器连接，并进行状态同步即可。
我们主要针对于第二种不存在Leader的情况进行分析。
具体过程：
任何时刻，只有处于“LOOKING”状态的机器才会尝试进行投票。
在这个投票消息中包含了两个最基本的消息：所推举的服务器的SID和ZXID，分别表示了被推举服务器的唯一标识和事务ID，所以我们以“(SID,ZXID)”的形式来标识一次投票信息。
现在，我们假设集群存活着3台机器，分别是Server1、Server2、Server3，SID和ZXID都分别为1、2、3。则投票分别为(1,1)、(2,2)、(3,3)。
第一次，Server1、Server2、Server3都选择自己作为Leader服务器来进行投票，并将自己的投票发给其他机器，同时会将自己的投票轮次计数器加1。
接收来自各个服务器的投票：当某台机器接收到投票会，会首先判断该投票的有效性，包括是否来自LOOKING状态的服务器、自己的选举轮次是否已经落后于该外部投票对应服务器的选举轮次，如果确实落后，就会立即更新自己的选举轮次，并且清空所有已经收到的投票，然后使用第一次的投票来进行比较以确定是否需要变更自己的投票，并将最终的投票结果发出。
-
处理投票：
在接收到来自其他服务器的投票后，针对于每一个投票，服务器都需要将别人的投票和自己的投票进行比较，规则是：优先选事务Id大的，相同再优先选编号大的- 对于Server1来说，它收到的投票是（2,2）和(3,3)，因为(3,3)的事务Id最大，所以优先选择(3,3)，于是Server1将自己的投票发送给其他服务器。
- 对于Server2来说，它收到的投票是(1,1)和(3,3)，因为(3,3)的事务Id最大，所以优先选择(3,3)，于是Server1将自己的投票发送给其他服务器。
- 对于Server3来说，它收到投票是(1,1)和(2,2)，因为事务Id都比自己小，所以自己无须更新自己的选票，只是再向集群中所有机器发出上一次投票信息即可。
统计投票
经过第二次投票后，集群中每个服务器都会统计所有投票，如果已经有超过半数的机器接收到相同的投票信息，就会认为该投票信息对应的机器称为Leader。改变服务器状态：
一旦确定了Leader，每个服务器就会更新自己的状态：如果是Follower，那么就变更为FOLLOWING，如果是Leader，那么就变更为LEADING。
小结
- 为什么选择事务ID比较大的机器？
因为事务Id越大，则代表这台机器的数据就越新，也就越能够保证数据的恢复。
Leader选举的实现细节
下面，我们从源码角度分析Zookeeper中对FastLeaderElection的实现。
投票数据结构
类路径：org.apache.zookeeper.server.quorum.Vote
public class Vote {
final private int version;
final private long id;
final private long zxid;
final private long electionEpoch;
final private long peerEpoch;
// .......
}
节点通信
在服务器启动时，每台机器都会启动一个QuorumCnxManager，负责各台服务器之间的底层Leader选举过程中的网络通信。QuorumCnxManager类路径。
-
消息收发队列
在QuorumCnxManager这个类内部维护了一系列的队列，用于保存接收到的、待发送的消息，以及消息的发送器。除接收队列外，这里提到的所有队列都有一个共同点 —— 按SID分组形成队列集合。
- recvQueue：消息接收队列，用于存放那些从其他服务器接收到的消息。
- queueSendMap：消息发送队列，用于保存那些待发送的消息。queueSendMap是一个Map，按照SID进行分组，分别为集群中的每台机器分配了一个单独队列，从而保证各台机器之间的消息发送互不影响。
- senderWorkerMap：发送器集合。每个SendWorker消息发送器，都对应一台远程Zookeeper服务器，负责消息的发送。同样，在senderWorkerMap中，也按照SID进行分组。
- lastMessageSent：最近发送过的消息。在这个集合中，为每个SID保留最近发送过的一个消息。
-
建立连接
为了能够进行互相投票，ZooKeeper集群中的所有机器都需要两两建立起网络连接。QuorumCnxManager在启动的时候，会创建一个ServerSocket来监听Leader选举的通信端口（Leader选举的通信端默认是3888）。开启端口监听后，ZooKeepr就能够不断地接收到来自其他服务器的“创建连接”请求，在接收到其他服务器的TCP连接请求时，为了避免两台机器之间重复地创建TCP连接，ZooKeeper设计了一种建立TCP连接的规则：只允许SID大的服务器主动和其他服务器建立连接，否则断开连接。服务器通过对比自己和远程服务器的SID值，来判断是否接受连接请求。如果当前服务器发现自己的SID值更大，那么会断开当前连接，然后自己主动去和远程服务器建立连接。
一旦建立起连接，就会根据远程服务器的SlD来创建相应的消息发送器SendWorker和消息接收器RecvWorker，并启动他们。
/*
* Listener thread
*/
public final Listener listener; // 构造方法初始化
public QuorumCnxManager(.....) {
// .....
// Starts listener thread that waits for connection requests
listener = new Listener();
// .....
} /**
* Thread to listen on some port
*/
public class Listener extends ZooKeeperThread { volatile ServerSocket ss = null; // ..... /**
* Sleeps on accept().
*/
@Override
public void run() {
int numRetries = 0;
InetSocketAddress addr;
while((!shutdown) && (numRetries < 3)){
try {
// 这里省略创建Socket和线程重命名过程
ss.bind(addr);
while (!shutdown) {
Socket client = ss.accept();
setSockOpts(client);
LOG.info("Received connection request "
+ client.getRemoteSocketAddress()); // 判断是否开启 sasl 权限校验
if (quorumSaslAuthEnabled) {
receiveConnectionAsync(client);
} else {
receiveConnection(client);
} numRetries = 0;
}
} catch (IOException e) {
// 这里省略 异常处理 部分代码
}
} // ........
} public void receiveConnection(final Socket sock) {
DataInputStream din = null;
try {
din = new DataInputStream(
new BufferedInputStream(sock.getInputStream())); handleConnection(sock, din);
} catch (IOException e) {
LOG.error("Exception handling connection, addr: {}, closing server connection",
sock.getRemoteSocketAddress());
closeSocket(sock);
}
} private void handleConnection(Socket sock, DataInputStream din)
throws IOException {
Long sid = null;
// ...... // 注意这里就是对SID 进行判断
if (sid < this.mySid) {
/*
* This replica might still believe that the connection to sid is
* up, so we have to shut down the workers before trying to open a
* new connection.
*/
SendWorker sw = senderWorkerMap.get(sid);
if (sw != null) {
sw.finish();
} /*
* 小连大，关闭小的，大的向小的重新发起连接
*/
LOG.debug("Create new connection to server: " + sid);
closeSocket(sock);
connectOne(sid); // Otherwise start worker threads to receive data.
} else {
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); if (!queueSendMap.containsKey(sid)) {
queueSendMap.put(sid, new ArrayBlockingQueue<ByteBuffer>(
SEND_CAPACITY));
} sw.start();
rw.start(); return;
}
}
} -
消息接收与发送
消息的接收过程是由消息接收器RecvWorker来负责的。ZooKeeper会为每个远程服务器分配一个单独的RecvWorker，每个RecvWorker只需要不断地从这个TCP连接中读取消息，并将其保存到recvQueue队列中。
消息发送过程也比较简单，由于ZooKeeper同样已经为每个远程服务器单独分别分配了消息发送器SendWorker，那么每个SendWorker只需要不断地从对应的消息发送队列中取出一个消息来发送即可，同时将这个消息放入lastMessageSent中来作为最近发送过的消息。在SendWorker的具体实现中，有一个细节需要我们注意一下：一旦Zookeeper发现针对当前远程服务器的消息发送队列为空，那么此时需要从lastMessageSent中取出一个最近发送过的消息来进行再次发送，这是为了解决接收方在消息接收前或者接收到消息后服务器挂了，导致消息尚未被正确处理。同时，Zookeeper能够保证接收方在处理消息时，会对重复消息进行正确的处理。
整体流程图如下：
FastLeaderElection 具体实现
/**
* 一旦QuorumPeer的状态变为LOOKING时，这个方法就会被调用 向其他节点发送消息，进行leader选举
*/
public Vote lookForLeader() throws InterruptedException {
//........
try {
HashMap<Long, Vote> recvset = new HashMap<Long, Vote>();
HashMap<Long, Vote> outofelection = new HashMap<Long, Vote>();
int notTimeout = finalizeWait;
// 选举轮次+1 & 初始化自己的选票 也就是第一次选自己的投票
synchronized(this){
logicalclock++;
updateProposal(getInitId(), getInitLastLoggedZxid(), getPeerEpoch());
}
// 广播自己的选票
sendNotifications();
// 不停循环选举，直到找到leader
while ((self.getPeerState() == ServerState.LOOKING) &&
(!stop)){
// 从接收队列中 获取消息
Notification n = recvqueue.poll(notTimeout,
TimeUnit.MILLISECONDS);
/*
* Sends more notifications if haven't received enough.
* Otherwise processes new notification.
*/
if(n == null){
if(manager.haveDelivered()){
//一旦Zookeeper发现针对当前远程服务器的消息发送队列为空，那么此时需要从lastMessageSent中取出一个最近发送过的消息来进行再次发送，
// 这是为了解决接收方在消息接收前或者接收到消息后服务器挂了，导致消息尚未被正确处理
sendNotifications();
} else {
manager.connectAll();
}
}
else if(self.getVotingView().containsKey(n.sid)) { // 收到投票信息 验证一下是否是自己所在集群中集群发出的投票消息
switch (n.state) {
case LOOKING:
// 外部选票轮次大于自己选票轮次（自己落后） , 操作如下：
// 1. 立即更新自己的选举轮次（logicalclock）
// 2. 清空本轮所有已经收到的投票
// 3. 将收到的选票和自己的初始投票做PK
if (n.electionEpoch > logicalclock) {
logicalclock = n.electionEpoch;
recvset.clear();
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) { //外部投票的选举轮次小于内部投票，直接忽略消息。
if(LOG.isDebugEnabled()){
LOG.debug("Notification election epoch is smaller than logicalclock. n.electionEpoch = 0x"
+ Long.toHexString(n.electionEpoch)
+ ", logicalclock=0x" + Long.toHexString(logicalclock));
}
break;
} else if (totalOrderPredicate(n.leader, n.zxid, n.peerEpoch,
proposedLeader, proposedZxid, proposedEpoch)) { // 外部选票和内部选票轮次一致 直接PK，然后更新自己的投票并广播出去
updateProposal(n.leader, n.zxid, n.peerEpoch);
sendNotifications();
}
if(LOG.isDebugEnabled()){
LOG.debug("Adding vote: from=" + n.sid +
", proposed leader=" + n.leader +
", proposed zxid=0x" + Long.toHexString(n.zxid) +
", proposed election epoch=0x" + Long.toHexString(n.electionEpoch));
}
// 保存本轮已经收到的投票 由于是Map且key是sid，所以只会保存每台机器最新的投票
recvset.put(n.sid, new Vote(n.leader, n.zxid, n.electionEpoch, n.peerEpoch));
// 判断自己选的节点是否有足够多的投票 ，如果是，则直接返回自己选节点，确定该节点为leader。
// 注意：终止的条件 不考虑权重的情况下是：this.half = n/2; set.size() > half ;
if (termPredicate(recvset,
new Vote(proposedLeader, proposedZxid,
logicalclock, proposedEpoch))) {
// Verify if there is any change in the proposed leader
// 等待finalizeWait时长，如果该时间段内，没有收到消息，则认定自己选举的节点就为leader了
while((n = recvqueue.poll(finalizeWait,
TimeUnit.MILLISECONDS)) != null){ //指定时间段内 又收到消息了
if(totalOrderPredicate(n.leader, n.zxid, n.peerEpoch,
proposedLeader, proposedZxid, proposedEpoch)){ //选票PK，如果自己的选票被PK下去了，则将新消息放入消息队列，重新开始另一轮循环。否则继续等待
recvqueue.put(n);
break;
}
}
/*
* 指定时间段内没有收到更高的选票，则认定自己选定的人就是leader，开始更新自己的状态
*/
if (n == null) {
//如果当前选择的是自己是leader，则更新自己状态为LEADING，否则更新自己状态是FOLLOWING或者OBSERVING
self.setPeerState((proposedLeader == self.getId()) ?
ServerState.LEADING: learningState());
Vote endVote = new Vote(proposedLeader,
proposedZxid,
logicalclock,
proposedEpoch);
leaveInstance(endVote);
return endVote;
}
}
break;
case OBSERVING:
LOG.debug("Notification from observer: " + n.sid);
break;
case FOLLOWING:
case LEADING:
/*
* 如果收到的选票 是一个状态为LEADING的机器发过来的，就验证一下是否是在同一选举轮次，
* 如果是，再验证自己收到的全部选票是否是证实该机器就是leader，如果是，则更新自己状态
*/
if(n.electionEpoch == logicalclock){
recvset.put(n.sid, new Vote(n.leader,
n.zxid,
n.electionEpoch,
n.peerEpoch));
if(ooePredicate(recvset, outofelection, n)) {
self.setPeerState((n.leader == self.getId()) ?
ServerState.LEADING: learningState());
Vote endVote = new Vote(n.leader,
n.zxid,
n.electionEpoch,
n.peerEpoch);
leaveInstance(endVote);
return endVote;
}
}
//保留外部选票
outofelection.put(n.sid, new Vote(n.version,
n.leader,
n.zxid,
n.electionEpoch,
n.peerEpoch,
n.state));
// 如果不在同一轮次，则根据本轮自身收到的全部外部选票再推断一下，该机器是否确实是leader
if(ooePredicate(outofelection, outofelection, n)) {
synchronized(this){
logicalclock = n.electionEpoch;
self.setPeerState((n.leader == self.getId()) ?
ServerState.LEADING: learningState());
}
Vote endVote = new Vote(n.leader,
n.zxid,
n.electionEpoch,
n.peerEpoch);
leaveInstance(endVote);
return endVote;
}
break;
default:
LOG.warn("Notification state unrecognized: {} (n.state), {} (n.sid)",
n.state, n.sid);
break;
}
} else {
LOG.warn("Ignoring notification from non-cluster member " + n.sid);
}
}
return null;
} finally {
// ......
}
}