Zookeeper选举(fastleaderelection算法)
1、选举相关概念:
选票:(myid,zxid,当前节点选取轮次,被推举服务器选举轮次,状态(looking))。
选举发生情况:启动时选举,运行时选举。
外部投票:其他服务器发送来的投票。
内部投票:服务器自身当前的投票。
选举轮次:epoch--leader选举周期。
pk:比较内部选票和外部选票,确定是否变更内部选票,主要是比较zxid和myid。
(1)每个服务器节点先初始化自己的选票,即(myid,zxid,当前节点选取轮次,被推举服务器选举轮次,状态(looking))。
(2)发送初始化选票到所有集群中的节点。
(3)接收外部选票
(4)判断选举轮次,内部选票选举轮次要是大于外部选票,就继续接收外部选票,如果小于等于外部的选举轮次,就进行选票pk,即判断自己是否要变更内部选票。
(5)变更内部选票,将选票发送至集群中。
(6)归档。每个节点将收到的所有外部选票进行归档。
(7)统计。判断是否有过半的服务器认可当前内部选票,如果是,那就选举结束,即超过一半选票同意新leader,那就成功。
2、选举过程:
Zookeeper选举Leader分为启动时选举和服务运行期间的选举。在往下看之前需要先了解服务器的几个状态:
- LOOKING:观望状态,此时还未选举出Leader
- LEADING:该服务器为Leader
- FOLLOWING:该服务器为Follower
- OBSERVING:该服务器为Observer
在构建Zookeeper集群时,最少服务器数量是2,但是服务器数量最好为奇数(因为需要过半服务器的支持才能完成投票和决策,如果是6台,那么最多允许挂掉2台服务器,存活4台进行投票决策;而如果是5台,那么最多允许挂掉的台数也是2台,但是只有3台进行投票决策。因此,相比较而言,奇数台服务器数量容错率更高的同时还降低了网络通信负担),因此,这里使用3台服务器说明,分别是server1、server2、server3。
启动时选举
启动服务器,当选举完成前,所有服务器的状态都是LOOKING。当启动server1(我们假设其myid为1,myid就是服务器id,需要自己配置,后面实际操作时会讲)时,一台服务器无法完成选举,因为需要过半服务器;然后启动server2(假设myid为2),这时两台服务器开始通信,并进入选举流程竞选Leader。
- 首先每台服务器都会将自己的myid和ZXID作为投票发送给其它服务器,因为是第一轮投票,所以假设ZXID都会0,那么server1的投票为(1,0),server2的投票为(2, 0)
- 服务器接收其它服务器的投票并检测投票是否有效,包括是否为同一轮投票,以及是否来自于LOOKING服务器
- 检验通过后,每个服务器都会将自己的投票和收到的投票进行比较。首先比较ZXID,选出最大的并更新为自己新的一轮投票,这里ZXID都是一样的,所以继续比较myid,同样选出最大的作为自己新的一轮投票。因此,这里server1会更新自己的投票为(2,0),而server2则是将自己之前的投票再重新投一次即可。
- 每一轮投票结束后,服务器都会统计投票信息,看看是否已经有服务器受到过半服务器的支持,若有,就将其作为Leader服务器,并将状态修改为LEADING,其它服务器状态则变为FOLLOWING。这里就是server2成为了Leader,选举结束。
当server3启动时,发现集群中已经存在Leader,则只需作为Follower服务器将入进去即可,不需要重新选举,除非Leader服务器挂掉。
服务运行期间的选举
服务运行期间Leader的选举其实在崩溃恢复那一节已经提及到,这里再详细说说。
- 当server2服务器崩溃时,剩余服务器因为找不到Leader,就会将自己的状态更新为LOOKING并进入Leader选举流程,这时候服务是不可用的。
- 存活服务器都会生成投票信息,因为服务已经运行一段时间,所以ZXID可能是不一样的,我们假设server1的投票为(1, 10),server3的投票为(3,11)。后面的流程就会启动时的选举是一样的了,只不过,server1在收到(3,11)投票后,只要比较ZXID即可。所以最终确定server3为新的LEADER。
Leader选举源码分析
从上文我们了解了Leader选举的核心原理,但代码层面是如何实现的呢?这就要通过分析其源码才能明白。
首先我们需要找到一个入口类,即Zookeeper集群启动的主类QuorumPeerMain:
public static void main(String[] args) {
QuorumPeerMain main = new QuorumPeerMain();
main.initializeAndRun(args);
}
protected void initializeAndRun(String[] args)
throws ConfigException, IOException
{
// 加载配置的类
QuorumPeerConfig config = new QuorumPeerConfig();
if (args.length == 1) {
// 从配置文件加载配置到内存中
config.parse(args[0]);
}
if (args.length == 1 && config.servers.size() > 0) {
// 配置集群
runFromConfig(config);
} else {
// there is only server in the quorum -- run as standalone
ZooKeeperServerMain.main(args);
}
}
public void runFromConfig(QuorumPeerConfig config) throws IOException {
try {
ServerCnxnFactory cnxnFactory = ServerCnxnFactory.createFactory();
cnxnFactory.configure(config.getClientPortAddress(),
config.getMaxClientCnxns());
// 将配置信息设置到QuorumPeer类
quorumPeer = new QuorumPeer();
quorumPeer.setClientPortAddress(config.getClientPortAddress());
quorumPeer.setTxnFactory(new FileTxnSnapLog(
new File(config.getDataLogDir()),
new File(config.getDataDir())));
quorumPeer.setQuorumPeers(config.getServers());
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.setQuorumVerifier(config.getQuorumVerifier());
quorumPeer.setCnxnFactory(cnxnFactory);
quorumPeer.setZKDatabase(new ZKDatabase(quorumPeer.getTxnFactory()));
quorumPeer.setLearnerType(config.getPeerType());
quorumPeer.setSyncEnabled(config.getSyncEnabled());
quorumPeer.setQuorumListenOnAllIPs(config.getQuorumListenOnAllIPs());
quorumPeer.start(); // 开启子线程加载db信息以及开始选举
quorumPeer.join(); // 主线程等待子线程完成
} catch (InterruptedException e) {
// warn, but generally this is ok
LOG.warn("Quorum Peer interrupted", e);
}
}
主要逻辑都在QuorumPeer类中,该类继承自Thread类:
public synchronized void start() {
loadDataBase(); // 这里是恢复DB信息,如epoch和ZXID等
cnxnFactory.start();
startLeaderElection(); //开始选举的流程
super.start(); // 启动线程
}
synchronized public void startLeaderElection() {
try {
// 投自己一票
currentVote = new Vote(myid, getLastLoggedZxid(), getCurrentEpoch());
} catch(IOException e) {
RuntimeException re = new RuntimeException(e.getMessage());
re.setStackTrace(e.getStackTrace());
throw re;
}
// 创建选举算法,默认是使用FastLeaderElection选举算法
this.electionAlg = createElectionAlgorithm(electionType);
}
protected Election createElectionAlgorithm(int electionAlgorithm){
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:
qcm = new QuorumCnxManager(this);
QuorumCnxManager.Listener listener = qcm.listener;
if(listener != null){
listener.start();
// 默认会进入到这里,可以在zoo.cfg配置文件中配置
le = new FastLeaderElection(this, qcm);
} else {
LOG.error("Null listener when initializing cnx manager");
}
break;
default:
assert false;
}
return le;
}
从上述代码中我们可以看到QuorumPeer创建选举算法的流程,默认是使用的是FastLeaderElection类(早期的版本中有LeaderElection、UDP版本的FastLeaderElection和TCP版本的FastLeaderElection,自3.4.0版本开始只保留了TCP版本的FastLeaderElection,我们也可以自己实现一个选举算法,然后在zoo.cfg配置文件配置即可)。选定选举算法后,调用了线程的start方法,那我们只需要找到run方法即可:
public void run() {
try {
while (running) {
// 根据服务器状态进入相应的流程,因为是选举流程,所以都是LOOKING状态,其它的流程可以暂时忽略
switch (getPeerState()) {
case LOOKING:
if (Boolean.getBoolean("readonlymode.enabled")) { // 当前服务器为只读服务器,与我们的流程无关
final ReadOnlyZooKeeperServer roZk = new ReadOnlyZooKeeperServer(
logFactory, this,
new ZooKeeperServer.BasicDataTreeBuilder(),
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();
setBCVote(null);
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 {
setBCVote(null);
// 选出leader
setCurrentVote(makeLEStrategy().lookForLeader());
} catch (Exception e) {
LOG.warn("Unexpected exception", e);
setPeerState(ServerState.LOOKING);
}
}
break;
}
}
} finally {
LOG.warn("QuorumPeer main thread exited");
try {
MBeanRegistry.getInstance().unregisterAll();
} catch (Exception e) {
LOG.warn("Failed to unregister with JMX", e);
}
jmxQuorumBean = null;
jmxLocalPeerBean = null;
}
}
Leader选举的细节主要就在FastLeaderElection.lookForLeader()(makeLEStrategy().lookForLeader())方法中:
// 发送和接收选票队列
LinkedBlockingQueue<ToSend> sendqueue;
LinkedBlockingQueue<Notification> recvqueue;
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;
// 第一次投票都投自己
synchronized(this){
logicalclock++;
updateProposal(getInitId(), getInitLastLoggedZxid(), getPeerEpoch());
}
// 发送自己的投票信息
sendNotifications();
// 循环直到选出Leader
while ((self.getPeerState() == ServerState.LOOKING) &&
(!stop)){
// 从队列中按顺序取出投票
Notification n = recvqueue.poll(notTimeout,
TimeUnit.MILLISECONDS);
if(n == null){ // 未收到任何投票信息
if(manager.haveDelivered()){ // 发送队列空闲情况下,就继续发送自己的投票信息
sendNotifications();
} else { // 发送队列不为null,可能是其它服务器还未启动,尝试重连
manager.connectAll();
}
}
else if(self.getVotingView().containsKey(n.sid)) { // 该消息是否属于当前集群
switch (n.state) { // 判断收到消息的节点的状态
case LOOKING:
// 判断是否是新一轮的选举
if (n.electionEpoch > logicalclock) {
logicalclock = n.electionEpoch; // 更新logicalclock
recvset.clear(); // 清空前一轮收到的投票信息
// 比较epoch、myid和zxid,并更新自己的投票为胜出的节点
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) { // 收到的投票信息已经过期,直接忽略
break;
} else if (totalOrderPredicate(n.leader, n.zxid, n.peerEpoch,
proposedLeader, proposedZxid, proposedEpoch)) {
// 同一轮投票直接比较myid和zxid
updateProposal(n.leader, n.zxid, n.peerEpoch);
sendNotifications();
}
recvset.put(n.sid, new Vote(n.leader, n.zxid, n.electionEpoch, n.peerEpoch));
// 判断选举是否结束,默认算法是超过半数同意
if (termPredicate(recvset,
new Vote(proposedLeader, proposedZxid,
logicalclock, proposedEpoch))) {
// 等待所有notification都被处理完,直到超时
while((n = recvqueue.poll(finalizeWait,
TimeUnit.MILLISECONDS)) != null){
if(totalOrderPredicate(n.leader, n.zxid, n.peerEpoch,
proposedLeader, proposedZxid, proposedEpoch)){
recvqueue.put(n);
break;
}
}
// leader已经确定
if (n == null) {
// 修改状态为leader或者follower
self.setPeerState((proposedLeader == self.getId()) ?
ServerState.LEADING: learningState());
Vote endVote = new Vote(proposedLeader,
proposedZxid,
logicalclock,
proposedEpoch);
leaveInstance(endVote);
return endVote;
}
}
break;
case OBSERVING: // observer不参与投票
LOG.debug("Notification from observer: " + n.sid);
break;
// follower和leader都要参与投票
case FOLLOWING:
case LEADING:
/*
* Consider all notifications from the same epoch
* together.
*/
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;
}
}
/*
* Before joining an established ensemble, verify
* a majority is following the same leader.
*/
outofelection.put(n.sid, new Vote(n.version,
n.leader,
n.zxid,
n.electionEpoch,
n.peerEpoch,
n.state));
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 {
try {
if(self.jmxLeaderElectionBean != null){
MBeanRegistry.getInstance().unregister(
self.jmxLeaderElectionBean);
}
} catch (Exception e) {
LOG.warn("Failed to unregister with JMX", e);
}
self.jmxLeaderElectionBean = null;
}
}
至此,Leader选举流程就结束了,但还有个问题,消息是如何广播的?就是sendNotifications方法:
private void sendNotifications() {
for (QuorumServer server : self.getVotingView().values()) {
long sid = server.id;
ToSend notmsg = new ToSend(ToSend.mType.notification,
proposedLeader,
proposedZxid,
logicalclock,
QuorumPeer.ServerState.LOOKING,
sid,
proposedEpoch);
if(LOG.isDebugEnabled()){
LOG.debug("Sending Notification: " + proposedLeader + " (n.leader), 0x" +
Long.toHexString(proposedZxid) + " (n.zxid), 0x" + Long.toHexString(logicalclock) +
" (n.round), " + sid + " (recipient), " + self.getId() +
" (myid), 0x" + Long.toHexString(proposedEpoch) + " (n.peerEpoch)");
}
sendqueue.offer(notmsg);
}
}
这个方法主要是将封装一个ToSend对象并加入到发送队列中,那这个队列是被谁消费的呢?浏览FastLeaderElection类结构,我们会看到WorkerSender和WorkerReceiver两个类,不用想,一个是接收,一个发送。我们这里是广播消息,那肯定就是WorkerSender类了(这两个类都是继承自Thread类的)。我们直接看run方法:
public void run() {
while (!stop) {
try {
ToSend m = sendqueue.poll(3000, TimeUnit.MILLISECONDS);
if(m == null) continue;
process(m); // 发送ToSend
} catch (InterruptedException e) {
break;
}
}
}
最终会调用QuorumCnxManager的toSend方法:
public void toSend(Long sid, ByteBuffer b) {
if (self.getId() == sid) { // 发送给自己不需要走网络通信,直接放到接收队列中即可
b.position(0);
addToRecvQueue(new Message(b.duplicate(), sid));
} else {
// 发送给其它节点,需要判断之前是否发送过
if (!queueSendMap.containsKey(sid)) {
// 未发送过则新建发送队列,SEND_CAPACITY为1,表示每次只发送一个消息
ArrayBlockingQueue<ByteBuffer> bq = new ArrayBlockingQueue<ByteBuffer>(
SEND_CAPACITY);
queueSendMap.put(sid, bq);
addToSendQueue(bq, b);
} else {
// 前一个消息还未发送完成,则重新发送
ArrayBlockingQueue<ByteBuffer> bq = queueSendMap.get(sid);
if(bq != null){
addToSendQueue(bq, b);
} else {
LOG.error("No queue for server " + sid);
}
}
connectOne(sid); // 真正的底层传输逻辑
}
}
至此Leader的选举分析就全部完成,总的也就涉及到以下几个类
- QuorumPeerMain:启动类
- QuorumPeer:集群环境辅助初始化类
- FastLeaderElection:选举算法的实现,其中包含了以下几个内部类:Notification:表示收到的投票信息ToSend:表示发送给其它服务器的投票信息Messager:包含了WorkerSender发送类和WorkerReceiver接受类,通过这两个类去发送和接收投票信息
补充:
zxid:
事务id, 为了保证事务的顺序一致性,zookeeper 采用了递增的事 务 id 号(zxid)来标识事务。所有的提议(proposal)都在被提出的时候加上了 zxid。实现中 zxid 是一个 64 位的 数字,它高32位是epoch(ZAB协议通过epoch编号来 区分 Leader 周期变化的策略)用来标识 leader 关系是否 改变,每次一个 leader 被选出来,它都会有一个新的 epoch=(原来的epoch+1),标识当前属于那个leader的 统治时期。低32位用于递增计数epoch的变化大家可以做一个简单的实验
- 启动一个zookeeper集群。
- 在/tmp/zookeeper/VERSION-2 路径下会看到一个 currentEpoch文件。文件中显示的是当前的epoch。
- 把 leader 节点停机,这个时候在看 currentEpoch 会有 变化。 随着每次选举新的leader,epoch都会发生变化。