Zookeeper源码分析

最新推荐文章于 2024-08-01 18:17:44 发布
最新推荐文章于 2024-08-01 18:17:44 发布
阅读量254 收藏
点赞数
分类专栏： 分布式 zookeeper 文章标签： zookeeper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lisheng5218/article/details/112393265
版权

一、ZK集群间通信类型

zookeeper集群间通信大体可分为四类：
数据同步型,服务器初始化型，请求处理型，会话管理型。

数据同步型：（leader和flower通信的端口号： 2888）
在这里插入图片描述
服务器初始化型（leader和flower通信的端口号： 2888）
在这里插入图片描述
请求处理型（client的端口号： 2181，NIO/Netty）
在这里插入图片描述
会话管理型（leader和flower通信的端口号： 2888）
在这里插入图片描述

二、ZK常用的几个常用端口号：

接收客户请求的端口号： 2181(NIO/Netty)
leader和flower通信的端口号： 2888
选举leader时通信的端口号： 3888(BIO)
其他服务与监控中心通信端口： 7070

三、ZK服务端启动流程

根据ZooKeeper启动脚本./zkServer.sh start -server ip:port，打开脚本可以看到服务端启动入口：org.apache.zookeeper.server.quorum.QuorumPeerMain

服务启动的调用流程如下：

QuorumPeerMain#main
	->QuorumPeerMain#initializeAndRun
		->QuorumPeerMain#runFromConfig
			->QuorumPeer#run

QuorumPeer#run的核心代码如下：

while (running) {
	switch (getPeerState()) {
	case LOOKING:
		// 当前节点是选举者,接下来就是就行选主
		LOG.info("LOOKING");
		try {
			setBCVote(null);
			setCurrentVote(makeLEStrategy().lookForLeader());
		} catch (Exception e) {
		//当前节点出现问题，需要节点状态重置为looking，下次循环则进行新一轮的选举
			LOG.warn("Unexpected exception", e);
			setPeerState(ServerState.LOOKING);
		}
		break;
	case OBSERVING:
		// 当前节点是观察者，则开始和leader建立连接并保持同步
		try {
			LOG.info("OBSERVING");
			setObserver(makeObserver(logFactory));
			observer.observeLeader();
		} catch (Exception e) {
			LOG.warn("Unexpected exception",e );                        
		} finally {
		//当前节点出现问题，需要节点状态重置为looking，下次循环则进行新一轮的选举
			observer.shutdown();
			setObserver(null);
			setPeerState(ServerState.LOOKING);
		}
		break;
	case FOLLOWING:
		// 当前节点是从节点，则开始和leader建立连接并保持同步
		try {
			LOG.info("FOLLOWING");
			setFollower(makeFollower(logFactory));
			follower.followLeader();
		} catch (Exception e) {
			LOG.warn("Unexpected exception",e);
		} finally {
		// 当前节点出现问题或者Leader节点挂掉，需要节点状态重置为looking，
		// 下次循环则进行新一轮的选举
			follower.shutdown();
			setFollower(null);
			setPeerState(ServerState.LOOKING);
		}
		break;
	case LEADING:
		// 当前节点是leader节点，就进行leader相关的初始化并启动leader.lead()
		LOG.info("LEADING");
		try {
			setLeader(makeLeader(logFactory));
			// leader存活时，周期性的向flower节点发送ping命令，保持心跳
			leader.lead();
			setLeader(null);
		} catch (Exception e) {
			LOG.warn("Unexpected exception",e);
		} finally {
			if (leader != null) {
				leader.shutdown("Forcing shutdown");
				setLeader(null);
			}
			//当前节点出现问题，需要节点状态重置为looking，下次循环则进行新一轮的选举
			setPeerState(ServerState.LOOKING);
		}
		break;
	}
}

四、选主流程

FastLeaderElection#lookForLeader核心代码如下：

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());
		}
		// 2、发送选票
		sendNotifications();

		/*
		 * Loop in which we exchange notifications until we find a leader
		 */

		while ((self.getPeerState() == ServerState.LOOKING) &&
				(!stop)){
			
			// 3、接收外部投票并处理
			/*
			 * Remove next notification from queue, times out after 2 times
			 * the termination time
			 */
			Notification n = recvqueue.poll(notTimeout,
					TimeUnit.MILLISECONDS);

			/*
			 * Only proceed if the vote comes from a replica in the
			 * voting view.
			 */
			switch (n.state) {
			case LOOKING:
				// 如果外部投票的轮次大于内部投票n.electionEpoch > logicalclock.get(),
				// 则立即更新自己的选举轮次logicalclock.set(n.electionEpoch); 
				// 并清空所有已经收到的投票recvset.clear()，然后使用初始化的投票来进行pk,
				// 并把内部投票发送出去
				// If notification > current, replace and send messages out
				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;
				// 外部投票的选举轮次和内部投票一致，开始pk选票
				} else if (totalOrderPredicate(n.leader, n.zxid, n.peerEpoch,
						proposedLeader, proposedZxid, proposedEpoch)) {
					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))) {

					// Verify if there is any change in the proposed leader
					while((n = recvqueue.poll(finalizeWait,
							TimeUnit.MILLISECONDS)) != null){
						if(totalOrderPredicate(n.leader, n.zxid, n.peerEpoch,
								proposedLeader, proposedZxid, proposedEpoch)){
							recvqueue.put(n);
							break;
						}
					}

					/*
					 * This predicate is true once we don't read any new
					 * relevant message from the reception queue
					 */
					if (n == null) {
						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:
			// 如果所接收服务器不在选举状态,也就是在FOLLOWING或者LEADING状态,做以下两个判断:
			// a、如果逻辑时钟相同,将该数据保存到recvset,如果所接收服务器宣称自己是leader,
			//    那么将判断是不是有半数以上的服务器选举它,如果是则设置选举状态退出选举过程
				/*
				 * 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;
					}
				}
			// b、 否则这是一条与当前逻辑时钟不符合的消息,那么说明在另一个选举过程中已经有了选举结果,
			// 于是将该选举结果加入到outofelection集合中,再根据outofelection来判断是否可以结束选举,
			// 如果可以也是保存逻辑时钟,设置选举状态,退出选举过程.
				/*
				 * 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;
			}
		}
		return null;
}

五、Leader节点挂掉之后，自动重新选主

1、Leader存活时，周期性的向Follower节点发送ping命令

while (true) {

*******

	// 设置心跳间隔时间
	Thread.sleep(self.tickTime / 2);
	if (!tickSkip) {
		self.tick++;
	}
	
*******

	for (LearnerHandler f : getLearners()) {
		// Synced set is used to check we have a supporting quorum, so only
		// PARTICIPANT, not OBSERVER, learners should be used
		if (f.synced() && f.getLearnerType() == LearnerType.PARTICIPANT) {
			syncedSet.add(f.getSid());
		}
		
		// 向Follower节点发送心跳信息-ping命令
		f.ping();
	}

*******
}

2、Follower节点会通过socket在while循环中不断接收leader传来的心跳信息

QuorumPacket qp = new QuorumPacket();
while (this.isRunning()) {
    readPacket(qp);
    processPacket(qp);
}

3、如果Leader挂掉，Follower节点接收不到消息，会抛异常，然后在finally中更新Follower状态为 LOOKING，由于Leader向所有的Follower都发送ping命令，所以如果Leader节点挂掉，所有节点都会变为LOOKING,会重新进行选举！

case FOLLOWING:
	try {
		LOG.info("FOLLOWING");
		setFollower(makeFollower(logFactory));
		follower.followLeader();
	} catch (Exception e) {
		LOG.warn("Unexpected exception",e);
	} finally {
		follower.shutdown();
		setFollower(null);
		//如果Leader节点挂掉，所有节点都会变为LOOKING,会重新进行选举
		setPeerState(ServerState.LOOKING);
	}
	break;
case LEADING:
	LOG.info("LEADING");
	try {
		setLeader(makeLeader(logFactory));
		leader.lead();
		setLeader(null);
	} catch (Exception e) {
		LOG.warn("Unexpected exception",e);
	} finally {
		if (leader != null) {
			leader.shutdown("Forcing shutdown");
			setLeader(null);
		}
		//如果Leader节点挂掉，所有节点都会变为LOOKING,会重新进行选举
		setPeerState(ServerState.LOOKING);
	}
	break;

六、ZK各节点之间选票收发通信逻辑

ZK在选票收发时，采用的多线程、多级队列的方式来进行处理的。作为基础架构，充分考虑了性能和解耦。而搞多个队列/线程，每个队列/线程绑定一个远程节点sid，是要保证在线程从队列中取数据互不影响。每个节点对应的线程去这个节点的队列中获取选票信息，多节点/线程可以防止某个节点出了问题，所有节点跟着阻塞的情况发生。

如下图：
在这里插入图片描述

Java部落格
关注
专栏目录
zookeeper源码分析之Record
qq_33513250的博客
12-27 531
目录 一、Record 二、OutputArchive 三、InputArchive 四、BinaryOutputArchive 五、BinaryInputArchive 六、DataNode 一、Record zookeeper通过维护内存中的DataTree和DataNode来向外提供数据节点服务，它也可以序列化持久至文件，反序列化至流中，进行网络请求传输等，所有zookee...
Zookeeper源码分析-Zookeeper角色
weixin_34362790的博客
09-09 70
本文首发于 www.yidooo.net/2014/10/18/… 转载请注明出处 在Zookeeper集群中，主要分为三者角色，而每一个节点同时只能扮演一种角色，这三种角色分别是： Leader：接受所有Follower的提案请求并统一协调发起提案的投票，负责与所有的Follower进行内部的数据交换(同步); Follower：直接为客户端服务并参与提案的投票，同时与Leader进行数据...
Zookeeper - 选举机制源码分析
最新发布
qq_73768123的博客
08-01 385
对于Leader选举，其总体框架图如下图所示说明：选举的父接口为Election，其定义了lookForLeader和shutdown两个方法，lookForLeader表示寻找Leader，shutdown则表示关闭，如关闭服务端之间的连接。AuthFastLeaderElection，同FastLeaderElection算法基本一致，只是在消息中加入了认证信息，其在3.4.0之后的版本中已经不建议使用。
ZooKeeper源码分析
weixin_38910645的博客
04-02 317
一、启动源码分析 Leader选举是保证分布式数据一致性的关键所在。ZooKeeper在初始化启动时和运行期间都可能进行Leader选举。Leader选举主要会在以下情况发生： 服务器初始化启动时 服务器运行期间Leader崩溃 服务器运行期间事务Zxid过大触发Leader选举 启动时选举 若进行Leader选举，则至少需要两台机器，这里选取3台机器组成的服务器集群为例。在集群初始化阶段，当...
zookeeper源码分析
04-10
第2章 ZooKeeper之序列化组件源码解析【透视现象，直击本质】 第4章 持久化【高手过招必备】 第6章 服务器启动 【由浅入深，先学好单机版，才能掌握集群版】 第7章 会话管理 【无处不在的会话其实没那么难】 第8章 ...
Zookeeper源码分析.epub
04-27
Zookeeper源码分析.epub
Go语言基础篇（3） —，2024年最新zookeeper源码分析
2301_82243558的博客
04-11 927
整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。其实面试这一块早在第一个说的25大面试专题就全都有的。以上提及的这些全部的面试+学习的各种笔记资料，我这差不多来回搞了三个多月，收集整理真的很不容易，其中还有很多自己的一些知识总结。正是因为很麻烦，所以对以上这些学习复习资料感兴趣一个人可以走的很快，但一群人才能走的更远。
Zookeeper源码分析(一)
qq_35151346的博客
11-13 384
一、选中Zookeeper 最近准备阅读一两个框架的源码，刚好准备学习关于分布式的知识，就选中了Zookeeper。关于选择这个框架有几个原因。 １．可以实现集群。 ２．服务注册与发现一直是分布式必须要研究与使用的。 ３．可以实现分布式锁 ４．等等，各种原因，让我选择了它。没办法，只能从官网开始慢慢探索源码之路。 二、学习方式 为了更好的开展后面的路子，准备...
ZooKeeper源码
08-22
zookeeper源码
ZooKeeper源码阅读
09-17
ZooKeeper源码阅读，庖丁解牛的带你进入zk的世界。ZooKeeper的类初始化 ZooKeeper在初始化的时候, 会调用类初始化方法, 初始化日志环境(使用SLF4J), 并且记录相关环境变量. 环境变量被存放在Environment的类中, 使用System.getProperty获得相应的环境变量, 内部使用Entry这个key-value的结构存放相应的环境变量名和值
zookeeper源码解析
weixin_42403127的博客
11-04 4007
zookeeper zookeeper工作机制 Zookeeper从设计模式角度来理解 ​ 是一个基于观察者模式设计的分布式服务管理框架，它负责存储和管理大家都关心的数据，然后接受观察者的注册，一旦这些数据的状态发生变化，Zookeeper就 将负责通知已经在Zookeeper上注册的那些观察者做出相应的反应。 zookeeper的特点 ​ 1）Zookeeper：一个领导者（Leader），多个跟随者（Follower）组成的集群。 ​ 2）集群中只要有半数以上节点存活，Zookeeper集群就能正常
Zookeeper-3.3.5源码分析与应用实践
13. 详细代码分析：对ZooKeeper源码进行了深入解读，有助于理解其内部工作原理。 此文档不仅适合ZooKeeper的初学者，也对有经验的开发者具有参考价值，能够帮助读者更好地理解和使用ZooKeeper，解决实际开发中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值