zookeeper --- 高级篇

大迂居士2023-08-12 9:57

一、zookeeper 事件监听机制

1.1、watcher概念

zookeeper提供了数据的发布/订阅功能，多个订阅者可同时监听某一特定主题对象，当该主题对象的自身状态发生变化时(例如节点内容改变、节点下的子节点列表改变等)，会实时、主动通知所有订阅者

zookeeper采用了Watcher机制实现数据的发布/订阅功能。该机制在被订阅对象发生变化时会异步通知客户端，因此客户端不必在Watcher注册后轮询阻塞，从而减轻了客户端压力。

zooKeeper 允许用户在指定节点上注册一些Watcher，并且在一些特定事件触发的时候，ZooKeeper 服务端会将事件通知到感兴趣的客户端上去，该机制是 ZooKeeper 实现分布式协调服务的重要特性。

zooKeeper 原生支持通过注册Watcher来进行事件监听，但是其使用并不是特别方便，需要开发人员自己反复注册Watcher，比较繁琐。

Curator引入了 Cache 来实现对 zooKeeper 服务端事件的监听。

watcher机制实际上与观察者模式类似，也可看作是一种观察者模式在分布式场景下的实现方式。

zooKeeper提供了三种Watcher：

  • NodeCache : 只是监听某一个特定的节点
  • PathChildrenCache : 监控一个ZNode的子节点.
  • TreeCache : 可以监控整个树上的所有节点，类似于PathChildrenCache和NodeCache的组合

1.2、watcher架构

Watcher实现由三个部分组成：

  • Zookeeper服务端
  • Zookeeper客户端
  • 客户端的ZKWatchManager对象

客户端首先将Watcher注册到服务端，同时将Watcher对象保存到客户端的Watch管

理器中。当ZooKeeper服务端监听的数据状态发生变化时，服务端会主动通知客户端，

接着客户端的Watch管理器会触发相关Watcher来回调相应处理逻辑，从而完成整体的数

据发布/订阅流程。

1.3、watcher特性

特性 说明
一次性 watcher是一次性的，一旦被触发就会移除，再次使用时需要重新注册
客户端顺序回调 watcher回调是顺序串行化执行的，只有回调后客户端才能看到最新的数据状态。一个watcher回调逻辑不应该太多，以免影响别的watcher执行
轻量级 WatchEvent是最小的通信单元，结构上只包含通知状态、事件类型和节点路径，并不会告诉数据节点变化前后的具体内容；
时效性 watcher只有在当前session彻底失效时才会无效，若在session有效期内快速重连成功，则watcher依然存在，仍可接收到通知；

1.4、watcher接口设计

Watcher是一个接口，任何实现了Watcher接口的类就是一个新的Watcher。

Watcher内部包含了两个枚举类：KeeperState、EventType

  • Watcher通知状态(KeeperState)
    • KeeperState是客户端与服务端连接状态发生变化时对应的通知类型。路径为
      org.apache.zookeeper.Watcher.Event.KeeperState，是一个枚举类，其枚举属性
      如下：
枚举属性 说明
SyncConnected 客户端与服务器正常连接时
Disconnected 客户端与服务器断开连接时
Expired 会话session失效时
AuthFailed 身份认证失败时
  • Watcher事件类型(EventType)
    • EventType是数据节点(znode)发生变化时对应的通知类型。EventType变化时
      KeeperState永远处于SyncConnected通知状态下；当KeeperState发生变化时，
      EventType永远为None。其路径为org.apache.zookeeper.Watcher.Event.EventType，
      是一个枚举类，枚举属性如下：
枚举属性 说明
None 无
NodeCreated Watcher监听的数据节点被创建时
NodeDeleted Watcher监听的数据节点被删除时
NodeDataChanged Watcher监听的数据节点内容发生变更时(无论内容数据是否变化)
NodeChildrenChanged Watcher监听的数据节点的子节点列表发生变更时

注：客户端接收到的相关事件通知中只包含状态及类型等信息，不包括节点变化前后的具体内容，变化前的数据需业务自身存储，变化后的数据需调用get等方法重新获取；

1.5、捕获相应的事件

上面讲到zookeeper客户端连接的状态和zookeeper对znode节点监听的事件类型，下面我们来讲解如何建立zookeeper的watcher监听。在zookeeper中采用zk.getChildren(path, watch)、zk.exists(path, watch)、zk.getData(path, watcher, stat)这样的方式为某个znode注册监听。

下表以node-x节点为例，说明调用的注册方法和可监听事件间的关系：

注册方式 Created ChildrenChanged Changed Deleted
zk.exists("/node-x",watcher) 可监控 可监控 可监控
zk.getData("/node-x",watcher) 可监控 可监控
zk.getChildren("/node-x",watcher) 可监控 可监控

1.6、注册watcher的方法

1.6.1、客服端与服务器的连接状态

java 复制代码 
KeeperState 通知状态
SyncConnected:客户端与服务器正常连接时
Disconnected:客户端与服务器断开连接时
Expired:会话session失效时
AuthFailed:身份认证失败时
事件类型为:None

1.6.2、检查节点是否存在

java 复制代码 
// 使用连接对象的监视器
exists(String path, boolean b)
// 自定义监视器
exists(String path, Watcher w)
// NodeCreated:节点创建
// NodeDeleted:节点删除
// NodeDataChanged:节点内容发生变化
  • path： znode路径。
  • b：是否使用连接对象中注册的监视器。
  • w：监视器对象。

1.6.3、查看节点

java 复制代码 
// 使用连接对象的监视器
getData(String path, boolean b, Stat stat)
// 自定义监视器
getData(String path, Watcher w, Stat stat)
// NodeDeleted:节点删除
// NodeDataChanged:节点内容发生变化
  • path： znode路径。
  • b：是否使用连接对象中注册的监视器。
  • w：监视器对象。
  • stat： 返回znode的元数据。

1.6.4、查看子节点

java 复制代码 
// 使用连接对象的监视器
getChildren(String path, boolean b)
// 自定义监视器
getChildren(String path, Watcher w)
// NodeChildrenChanged:子节点发生变化
// NodeDeleted:节点删除
  • path： znode路径。
  • b： 是否使用连接对象中注册的监视器。
  • w：监视器对象。

1.7、配置中心案例

工作中有这样的一个场景: 数据库用户名和密码信息放在一个配置文件中，应用读取该配置文件，配置文件信息放入缓存。

若数据库的用户名和密码改变时候，还需要重新加载缓存，比较麻烦，通过ZooKeeper可以轻松完成，当数据库发生变化时自动完成缓存同步。

设计思路：

  1. 连接zookeeper服务器
  2. 读取zookeeper中的配置信息，注册watcher监听器，存入本地变量
  3. 当zookeeper中的配置信息发生变化时，通过watcher的回调方法捕获数据变化事件
  4. 重新获取配置信息

案例:

java 复制代码 
public class MyConfigCenter implements Watcher {
	// zk的连接串
	String IP = "192.168.60.130:2181";
	// 计数器对象
	CountDownLatch countDownLatch = new CountDownLatch(1);
	// 连接对象
	static ZooKeeper zooKeeper;
	
	// 用于本地化存储配置信息
	private String url;
	private String username;
	private String password;
	
	@Override
	public void process(WatchedEvent event) {
		try {
				// 捕获事件状态
			if (event.getType() == Event.EventType.None) {
				if (event.getState() == Event.KeeperState.SyncConnected){
					System.out.println("连接成功");
					countDownLatch.countDown();
				} else if (event.getState() ==Event.KeeperState.Disconnected) {
					System.out.println("连接断开!");
				} else if (event.getState() == Event.KeeperState.Expired){
					System.out.println("连接超时!");
					// 超时后服务器端已经将连接释放，需要重新连接服务器端
					zooKeeper = new ZooKeeper("192.168.60.130:2181",6000,new ZKConnectionWatcher());
				} else if (event.getState() ==Event.KeeperState.AuthFailed) {
					System.out.println("验证失败!");
				}
			// 当配置信息发生变化时
			} else if (event.getType() == EventType.NodeDataChanged) {
				initValue();
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
	
	// 构造方法
	public MyConfigCenter() {
		initValue();
	}
	
	// 连接zookeeper服务器，读取配置信息
	public void initValue() {
		try {
			// 创建连接对象
			zooKeeper = new ZooKeeper(IP, 5000, this);
			// 阻塞线程，等待连接的创建成功
			countDownLatch.await();
			// 读取配置信息
			this.url = new String(zooKeeper.getData("/config/url", true,null));
			this.username = new String(zooKeeper.getData("/config/username", true, null));
			this.password = new String(zooKeeper.getData("/config/password", true, null));
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}

	public static void main(String[] args) {
		try {
			MyConfigCenter myConfigCenter = new MyConfigCenter();
			for (int i = 1; i <= 20; i++) {
				Thread.sleep(5000);
				System.out.println("url:"+myConfigCenter.getUrl());
				System.out.println("username:"+myConfigCenter.getUsername());
				System.out.println("password:"+myConfigCenter.getPassword());
				System.out.println("########################################");
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
	
	public String getUrl() {
		return url;
	}
	public void setUrl(String url) {
		this.url = url;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
}

1.8、生成分布式唯一ID

在过去的单库单表型系统中，通常可以使用数据库字段自带的auto_increment

属性来自动为每条记录生成一个唯一的ID。但是分库分表后，就无法在依靠数据库的

auto_increment属性来唯一标识一条记录了。此时我们就可以用zookeeper在分布式环

境下生成全局唯一ID。

设计思路：

  1. 连接zookeeper服务器
  2. 指定路径生成临时有序节点
  3. 取序列号及为分布式环境下的唯一ID

案例:

java 复制代码 
public class GloballyUniqueId implements Watcher {
	// zk的连接串
	String IP = "192.168.60.130:2181";
	// 计数器对象
	CountDownLatch countDownLatch = new CountDownLatch(1);
	// 用户生成序号的节点
	String defaultPath = "/uniqueId";
	// 连接对象
	ZooKeeper zooKeeper;
	
	@Override
	public void process(WatchedEvent event) {
		try {
			// 捕获事件状态
			if (event.getType() == Watcher.Event.EventType.None) {
				if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
					System.out.println("连接成功");
					countDownLatch.countDown();
				} else if (event.getState() == Watcher.Event.KeeperState.Disconnected) {
					System.out.println("连接断开!");
				} else if (event.getState() == Watcher.Event.KeeperState.Expired) {
					System.out.println("连接超时!");
					// 超时后服务器端已经将连接释放，需要重新连接服务器端
					zooKeeper = new ZooKeeper(IP, 6000, new ZKConnectionWatcher());
				} else if (event.getState() == Watcher.Event.KeeperState.AuthFailed) {
					System.out.println("验证失败!");
				}
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
	
	// 构造方法
	public GloballyUniqueId() {
		try {
			//打开连接
			zooKeeper = new ZooKeeper(IP, 5000, this);
			// 阻塞线程，等待连接的创建成功
			countDownLatch.await();
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
	
	// 生成id的方法
	public String getUniqueId() {
		String path = "";
		try {
			//创建临时有序节点
			path = zooKeeper.create(defaultPath, new byte[0],Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		// /uniqueId0000000001
		return path.substring(9);
	}
	
	public static void main(String[] args) {
		GloballyUniqueId globallyUniqueId = new GloballyUniqueId();
		for (int i = 1; i <= 5; i++) {
			String id = globallyUniqueId.getUniqueId();
			System.out.println(id);
		}
	}
}

1.9、分布式锁

分布式锁有多种实现方式，比如通过数据库、redis都可实现。作为分布式协同工具ZooKeeper，当然也有着标准的实现方式。下面介绍在zookeeper中如何实现排他锁。

设计思路：

  1. 每个客户端往/Locks下创建临时有序节点/Locks/Lock_000000001
  2. 客户端取得/Locks下子节点，并进行排序，判断排在最前面的是否为自己，如果自己的锁节点在第一位，代表获取锁成功
  3. 如果自己的锁节点不在第一位，则监听自己前一位的锁节点。例如，自己锁节点Lock_000000001
  4. 当前一位锁节点（Lock_000000002）的逻辑
  5. 监听客户端重新执行第2步逻辑，判断自己是否获得了锁

案例:

java 复制代码 
public class MyLock {
	// zk的连接串
	String IP = "192.168.60.130:2181";
	// 计数器对象
	CountDownLatch countDownLatch = new CountDownLatch(1);
	//ZooKeeper配置信息
	ZooKeeper zooKeeper;
	
	private static final String LOCK_ROOT_PATH = "/Locks";
	private static final String LOCK_NODE_NAME = "Lock_";
	private String lockPath;
	
	// 打开zookeeper连接
	public MyLock() {
		try {
			zooKeeper = new ZooKeeper(IP, 5000, new Watcher() {
				@Override
				public void process(WatchedEvent event) {
					if (event.getType() == Event.EventType.None) {
						if (event.getState() ==Event.KeeperState.SyncConnected) {
							System.out.println("连接成功!");
							countDownLatch.countDown();
						}
					}
				}
			});
			countDownLatch.await();
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
	
	//获取锁
	public void acquireLock() throws Exception {
		//创建锁节点
		createLock();
		//尝试获取锁
		attemptLock();
	}
	
	//创建锁节点
	private void createLock() throws Exception {
		//判断Locks是否存在，不存在创建
		Stat stat = zooKeeper.exists(LOCK_ROOT_PATH, false);
		if (stat == null) {
			zooKeeper.create(LOCK_ROOT_PATH, new byte[0],
			ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
		}
		// 创建临时有序节点
		lockPath = zooKeeper.create(LOCK_ROOT_PATH + "/" + LOCK_NODE_NAME, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
		System.out.println("节点创建成功:" + lockPath);
	}
	
	//监视器对象，监视上一个节点是否被删除
	Watcher watcher = new Watcher() {
		@Override
		public void process(WatchedEvent event) {
			if (event.getType() == Event.EventType.NodeDeleted) {
				synchronized (this) {
					notifyAll();
				}
			}
		}
	};
	
	//尝试获取锁
	private void attemptLock() throws Exception {
		// 获取Locks节点下的所有子节点
		List<String> list = zooKeeper.getChildren(LOCK_ROOT_PATH, false);
		// 对子节点进行排序
		Collections.sort(list);
		// /Locks/Lock_000000001
		int index = list.indexOf(lockPath.substring(LOCK_ROOT_PATH.length() + 1));
		if (index == 0) {
			System.out.println("获取锁成功!");
			return;
		} else {
			// 上一个节点的路径
			String path = list.get(index ‐ 1);
			Stat stat = zooKeeper.exists(LOCK_ROOT_PATH + "/" + path,watcher);
			if (stat == null) {
				attemptLock();
			} else {
				synchronized (watcher) {
					watcher.wait();
				}
				attemptLock();
			}
		}
	}
	
	//释放锁
	public void releaseLock() throws Exception {
		//删除临时有序节点
		zooKeeper.delete(this.lockPath,‐1);
		zooKeeper.close();
		System.out.println("锁已经释放:"+this.lockPath);
	}
	
	public static void main(String[] args) {
		try {
			MyLock myLock = new MyLock();
			myLock.createLock();
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}
java 复制代码 
public class TicketSeller {
	private void sell(){
		System.out.println("售票开始");
		// 线程随机休眠数毫秒，模拟现实中的费时操作
		int sleepMillis = 5000;
		try {
			//代表复杂逻辑执行了一段时间
			Thread.sleep(sleepMillis);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("售票结束");
	}
	
	public void sellTicketWithLock() throws Exception {
		MyLock lock = new MyLock();
		// 获取锁
		lock.acquireLock();
		sell();
		//释放锁
		lock.releaseLock();
	}
	
	public static void main(String[] args) throws Exception {
		TicketSeller ticketSeller = new TicketSeller();
		for(int i=0;i<10;i++){
			ticketSeller.sellTicketWithLock();
		}
	}
}

zooKeeper分布式锁原理

  • 核心思想：当客户端要获取锁，则创建节点，使用完锁，则删除该节点。
  • 客户端获取锁时，在lock节点下创建临时顺序节点。
  • 然后获取lock下面的所有子节点，客户端获取到所有的子节点之后，如果发现自己创建的子节点序号最小，那么就认为该客户端获取到了锁。使用完锁后，将该节点删除。
  • 如果发现自己创建的节点并非lock所有子节点中最小的，说明自己还没有获取到锁，此时客户端需要找到比自己小的那个节点，同时对其注册事件监听器，监听删除事件。
  • 如果发现比自己小的那个节点被删除，则客户端的Watcher会收到相应通知，此时再次判断自己创建的节点是否是lock子节点中序号最小的，如果是则获取到了锁，如果不是则重复以上步骤继续获取到比自己小的一个节点并注册监听。

二、zookeeper 集群搭建

2.1、搭建要求

真实的集群是需要部署在不同的服务器上的，但是在我们测试时同时启动很多个虚拟机内存会吃不消，所以我们通常会搭建伪集群，也就是把所有的服务都搭建在一台虚拟机上，用端口进行区分。

我们这里要求搭建一个三个节点的Zookeeper集群（伪集群）。

2.2、准备工作

重新部署一台虚拟机作为我们搭建集群的测试服务器。

（1）安装JDK 【此步骤省略】。

（2）Zookeeper压缩包上传到服务器

（3）将Zookeeper解压 ，建立/usr/local/zookeeper-cluster目录，将解压后的Zookeeper复制到以下三个目录

/usr/local/zookeeper-cluster/zookeeper-1

/usr/local/zookeeper-cluster/zookeeper-2

/usr/local/zookeeper-cluster/zookeeper-3

shell 复制代码 
[root@localhost ~]# mkdir /usr/local/zookeeper-cluster
[root@localhost ~]# cp -r  apache-zookeeper-3.5.6-bin /usr/local/zookeeper-cluster/zookeeper-1
[root@localhost ~]# cp -r  apache-zookeeper-3.5.6-bin /usr/local/zookeeper-cluster/zookeeper-2
[root@localhost ~]# cp -r  apache-zookeeper-3.5.6-bin /usr/local/zookeeper-cluster/zookeeper-3

（4）创建data目录 ，并且将 conf下zoo_sample.cfg 文件改名为 zoo.cfg

shell 复制代码 
mkdir /usr/local/zookeeper-cluster/zookeeper-1/data
mkdir /usr/local/zookeeper-cluster/zookeeper-2/data
mkdir /usr/local/zookeeper-cluster/zookeeper-3/data

mv  /usr/local/zookeeper-cluster/zookeeper-1/conf/zoo_sample.cfg  /usr/local/zookeeper-cluster/zookeeper-1/conf/zoo.cfg
mv  /usr/local/zookeeper-cluster/zookeeper-2/conf/zoo_sample.cfg  /usr/local/zookeeper-cluster/zookeeper-2/conf/zoo.cfg
mv  /usr/local/zookeeper-cluster/zookeeper-3/conf/zoo_sample.cfg  /usr/local/zookeeper-cluster/zookeeper-3/conf/zoo.cfg

（5） 配置每一个Zookeeper 的dataDir 和 clientPort 分别为2181 2182 2183

修改/usr/local/zookeeper-cluster/zookeeper-1/conf/zoo.cfg

shell 复制代码 
vim /usr/local/zookeeper-cluster/zookeeper-1/conf/zoo.cfg

clientPort=2181
dataDir=/usr/local/zookeeper-cluster/zookeeper-1/data

修改/usr/local/zookeeper-cluster/zookeeper-2/conf/zoo.cfg

shell 复制代码 
vim /usr/local/zookeeper-cluster/zookeeper-2/conf/zoo.cfg

clientPort=2182
dataDir=/usr/local/zookeeper-cluster/zookeeper-2/data

修改/usr/local/zookeeper-cluster/zookeeper-3/conf/zoo.cfg

shell 复制代码 
vim /usr/local/zookeeper-cluster/zookeeper-3/conf/zoo.cfg

clientPort=2183
dataDir=/usr/local/zookeeper-cluster/zookeeper-3/data

2.3、配置集群

（1）在每个zookeeper的 data 目录下创建一个 myid 文件，内容分别是1、2、3 。这个文件就是记录每个服务器的ID

shell 复制代码 
echo 1 >/usr/local/zookeeper-cluster/zookeeper-1/data/myid
echo 2 >/usr/local/zookeeper-cluster/zookeeper-2/data/myid
echo 3 >/usr/local/zookeeper-cluster/zookeeper-3/data/myid

（2）在每一个zookeeper 的 zoo.cfg配置客户端访问端口（clientPort）和集群服务器IP列表。

集群服务器IP列表如下

shell 复制代码 
vim /usr/local/zookeeper-cluster/zookeeper-1/conf/zoo.cfg
vim /usr/local/zookeeper-cluster/zookeeper-2/conf/zoo.cfg
vim /usr/local/zookeeper-cluster/zookeeper-3/conf/zoo.cfg

server.1=192.168.149.135:2881:3881
server.2=192.168.149.135:2882:3882
server.3=192.168.149.135:2883:3883

解释：server.服务器ID=服务器IP地址：服务器之间通信端口：服务器之间投票选举端口

2.4、启动集群

启动集群就是分别启动每个实例。

shell 复制代码 
/usr/local/zookeeper-cluster/zookeeper-1/bin/zkServer.sh start
/usr/local/zookeeper-cluster/zookeeper-2/bin/zkServer.sh start
/usr/local/zookeeper-cluster/zookeeper-3/bin/zkServer.sh start

启动后我们查询一下每个实例的运行状态

shell 复制代码 
/usr/local/zookeeper-cluster/zookeeper-1/bin/zkServer.sh status
/usr/local/zookeeper-cluster/zookeeper-2/bin/zkServer.sh status
/usr/local/zookeeper-cluster/zookeeper-3/bin/zkServer.sh status

先查询第一个服务

Mode为follower表示是跟随者（从）

再查询第二个服务Mod 为leader表示是领导者（主）

查询第三个为跟随者（从）

2.5、模拟集群异常

（1）首先我们先测试如果是从服务器挂掉，会怎么样

把3号服务器停掉，观察1号和2号，发现状态并没有变化

shell 复制代码 
/usr/local/zookeeper-cluster/zookeeper-3/bin/zkServer.sh stop
/usr/local/zookeeper-cluster/zookeeper-1/bin/zkServer.sh status
/usr/local/zookeeper-cluster/zookeeper-2/bin/zkServer.sh status

由此得出结论，3个节点的集群，从服务器挂掉，集群正常

（2）我们再把1号服务器（从服务器）也停掉，查看2号（主服务器）的状态，发现已经停止运行了。

shell 复制代码 
/usr/local/zookeeper-cluster/zookeeper-1/bin/zkServer.sh stop
/usr/local/zookeeper-cluster/zookeeper-2/bin/zkServer.sh status

由此得出结论，3个节点的集群，2个从服务器都挂掉，主服务器也无法运行。因为可运行的机器没有超过集群总数量的半数。

（3）我们再次把1号服务器启动起来，发现2号服务器又开始正常工作了。而且依然是领导者。

shell 复制代码 
/usr/local/zookeeper-cluster/zookeeper-1/bin/zkServer.sh start

/usr/local/zookeeper-cluster/zookeeper-2/bin/zkServer.sh status

（4）我们把3号服务器也启动起来，把2号服务器停掉,停掉后观察1号和3号的状态。

shell 复制代码 
/usr/local/zookeeper-cluster/zookeeper-3/bin/zkServer.sh start
/usr/local/zookeeper-cluster/zookeeper-2/bin/zkServer.sh stop

/usr/local/zookeeper-cluster/zookeeper-1/bin/zkServer.sh status
/usr/local/zookeeper-cluster/zookeeper-3/bin/zkServer.sh status

发现新的leader产生了~

由此我们得出结论，当集群中的主服务器挂了，集群中的其他服务器会自动进行选举状态，然后产生新得leader

（5）我们再次测试，当我们把2号服务器重新启动起来启动后，会发生什么？2号服务器会再次成为新的领导吗？我们看结果

shell 复制代码 
/usr/local/zookeeper-cluster/zookeeper-2/bin/zkServer.sh start

/usr/local/zookeeper-cluster/zookeeper-2/bin/zkServer.sh status
/usr/local/zookeeper-cluster/zookeeper-3/bin/zkServer.sh status


我们会发现，2号服务器启动后依然是跟随者（从服务器），3号服务器依然是领导者（主服务器），没有撼动3号服务器的领导地位。
由此我们得出结论，当领导者产生后，再次有新服务器加入集群，不会影响到现任领导者。

2.6、zookeeper 集群角色

在ZooKeeper集群服中务中有三个角色：

  • Leader 领导者 ：

    • 处理事务请求
    • 集群内部各服务器的调度者

  • Follower 跟随者 ：

    • 处理客户端非事务请求，转发事务请求给Leader服务器
    • 参与Leader选举投票

  • Observer 观察者：

    • 处理客户端非事务请求，转发事务请求给Leader服务器

三、一致性协议:zab协议

zab协议 的全称是 Zookeeper Atomic Broadcast （zookeeper原子广播）。zookeeper 是通过 zab协议来保证分布式事务的最终一致性

  1. leader从客户端收到一个写请求
  2. leader生成一个新的事务并为这个事务生成一个唯一的ZXID
  3. leader将这个事务提议(propose)发送给所有的follows节点
  4. follower节点将收到的事务请求加入到历史队列(history queue)中,并发送ack给
    leader
  5. 当leader收到大多数follower（半数以上节点）的ack消息，leader会发送commit请
    求
  6. 当follower收到commit请求时，从历史队列中将事务请求commit

四、zookeeper的leader选举

4.1?服务器状态

  • looking：寻找leader状态。当服务器处于该状态时，它会认为当前集群中没有
  • leader，因此需要进入leader选举状态。
  • leading： 领导者状态。表明当前服务器角色是leader。
  • following： 跟随者状态。表明当前服务器角色是follower。
  • observing：观察者状态。表明当前服务器角色是observer。

4.2、服务器启动时期的leader选举

在集群初始化阶段，当有一台服务器server1启动时，其单独无法进行和完成leader选举，当第二台服务器server2启动时，此时两台机器可以相互通信，每台机器都试图找到leader，于是进入leader选举过程。选举过程如下:

    1. 每个server发出一个投票。由于是初始情况，server1和server2都会将自己作为leader服务器来进行投票，每次投票会包含所推举的服务器的myid和zxid，使用(myid, zxid)来表示，此时server1的投票为(1, 0)，server2的投票为(2, 0)，然后各自将这个投票发给集群中其他机器。
    1. 集群中的每台服务器接收来自集群中各个服务器的投票。
    1. 处理投票。针对每一个投票，服务器都需要将别人的投票和自己的投票进行pk，pk规则如下
    • 检查zxid。zxid比较大的服务器优先作为leader。
    • 如果zxid相同，那么就比较myid。myid较大的服务器作为leader服务器。
    • 对于Server1而言，它的投票是(1, 0)，接收Server2的投票为(2, 0)，首先会比较两者的zxid，均为0，再比较myid，此时server2的myid最大，于是更新自己的投票为(2, 0)，然后重新投票，对于server2而言，其无须更新自己的投票，只是再次向集群中所有机器发出上一次投票信息即可。
    1. 统计投票。每次投票后，服务器都会统计投票信息，判断是否已经有过半机器接受到相同的投票信息，对于server1、server2而言，都统计出集群中已经有两台机器接受了(2, 0)的投票信息，此时便认为已经选出了leader
    1. 改变服务器状态。一旦确定了leader，每个服务器就会更新自己的状态，如果是follower，那么就变更为following，如果是leader，就变更为leading。

4.3、服务器运行时期的Leader选举

在zookeeper运行期间，leader与非leader服务器各司其职，即便当有非leader服务器宕机或新加入，此时也不会影响leader，但是一旦leader服务器挂了，那么整个集群将暂停对外服务，进入新一轮leader选举，其过程和启动时期的Leader选举过程基本一致。

假设正在运行的有server1、server2、server3三台服务器，当前leader是server2，若某一时刻leader挂了，此时便开始Leader选举。选举过程如下:

  1. 变更状态。leader挂后，余下的服务器都会将自己的服务器状态变更为looking，然后开始进入leader选举过程。

  2. 每个server会发出一个投票。在运行期间，每个服务器上的zxid可能不同，此时假定server1的zxid为122，server3的zxid为122，在第一轮投票中，server1和server3都会投自己，产生投票(1, 122)，(3, 122)，然后各自将投票发送给集群中所有机器。

  3. 接收来自各个服务器的投票。与启动时过程相同

  4. 处理投票。与启动时过程相同，此时，server3将会成为leader。

  5. 统计投票。与启动时过程相同。

  6. 改变服务器的状态。与启动时过程相同。

五、observer角色及其配置

observer角色特点：

  • 不参与集群的leader选举
  • 不参与集群中写数据时的ack反馈
  • 为了使用observer角色，在任何想变成observer角色的配置文件中加入如下配
    置：
yaml 复制代码 
peerType=observer

并在所有server的配置文件中，配置成observer模式的server的那行配置追加:observer，例如：

shell 复制代码 
server.3=192.168.60.130:2289:3389:observer

六、zookeeperAPI连接集群

java 复制代码 
ZooKeeper(String connectionString, int sessionTimeout, Watcher watcher)
  • connectionString ： zooKeeper集合主机。
  • sessionTimeout ： 会话超时（以毫秒为单位）。
  • watcher ： 实现"监视器"界面的对象。ZooKeeper集合通过监视器对象返回连接状
    态。
java 复制代码 
public class ZookeeperConnection {
	public static void main(String[] args) {
		try {
			// 计数器对象
			CountDownLatch countDownLatch=new CountDownLatch(1);
			// arg1:服务器的ip和端口
			// arg2:客户端与服务器之间的会话超时时间 以毫秒为单位的
			// arg3:监视器对象
			ZooKeeper zooKeeper=new ZooKeeper("192.168.60.130:2181,192.168.60.130:2182,192.168.60.130:2183",5000, new Watcher() {
				@Override
				public void process(WatchedEvent event) {
					if(event.getState()==Event.KeeperState.SyncConnected){
						System.out.println("连接创建成功!");
						countDownLatch.countDown();
					}
				}
			});
			// 主线程阻塞等待连接对象的创建成功
			countDownLatch.await();
			// 会话编号
			System.out.println(zooKeeper.getSessionId());
			zooKeeper.close();
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

七、zookeeper四字监控命令

zooKeeper支持某些特定的四字命令与其的交互。它们大多是查询命令，用来获取 zooKeeper服务的当前状态及相关信息。用户在客户端可以通过 telnet 或 nc 向zooKeeper提交相应的命令。 zooKeeper常用四字命令见下表 所示：

命令 描述
conf 输出相关服务配置的详细信息。比如端口、zk数据及日志配置路径、最大连接数，session超时时间、serverId等
cons 列出所有连接到这台服务器的客户端连接/会话的详细信息。包括"接受/发送"的包数量、session id 、操作延迟、最后的操作执行等信息
crst 重置当前这台服务器所有连接/会话的统计信息
dump 列出未经处理的会话和临时节点
envi 输出关于服务器的环境详细信息
ruok 测试服务是否处于正确运行状态。如果正常返回"imok"，否则返回空
stat 输出服务器的详细信息：接收/发送包数量、连接数、模式（leader/follower）、节点总数、延迟。 所有客户端的列表
srst 重置server状态
wchs 列出服务器watches的简洁信息：连接总数、watching节点总数和watches总数
wchc 通过session分组，列出watch的所有节点，它的输出是一个与 watch 相关的会话的节点列表
mntr 列出集群的健康状态。包括"接受/发送"的包数量、操作延迟、当前服务模式（leader/follower）、节点总数、watch总数、临时节点总数

nc命令工具安装:

shell 复制代码 
#root用户安装
#下载安装包
wget http://vault.centos.org/6.6/os/x86_64/Packages/nc-1.84-
22.el6.x86_64.rpm
#rpm安装
rpm -iUv nc-1.84-22.el6.x86_64.rpm

使用方式，在shell终端输入：echo mntr | nc localhost 2181

九、taokeeper监控工具的使用

基于zookeeper的监控管理工具taokeeper，由淘宝团队开源的zk管理中间件，安装前要求服务前先配置nc 和 sshd

1.下载数据库脚本

powershell 复制代码 
wget https://github.com/downloads/alibaba/taokeeper/taokeeper.sql

2.下载主程序

powershell 复制代码 
wget https://github.com/downloads/alibaba/taokeeper/taokeepermonitor.tar.gz

3.下载配置文件

powershell 复制代码 
wget https://github.com/downloads/alibaba/taokeeper/taokeeper-monitorconfig.propertie

4.配置 taokeeper-monitor-config.properties

yaml 复制代码 
#Daily
systemInfo.envName=DAILY
#DBCP
dbcp.driverClassName=com.mysql.jdbc.Driver
#mysql连接的ip地址端口号
dbcp.dbJDBCUrl=jdbc:mysql://192.168.60.130:3306/taokeeper
dbcp.characterEncoding=GBK
#用户名
dbcp.username=root
#密码
dbcp.password=root
dbcp.maxActive=30
dbcp.maxIdle=10
dbcp.maxWait=10000
#SystemConstant
#用户存储内部数据的文件夹
#创建/home/zookeeper/taokeeperdata/ZooKeeperClientThroughputStat
SystemConstent.dataStoreBasePath=/home/zookeeper/taokeeperdata
#ssh用户
SystemConstant.userNameOfSSH=zookeeper
#ssh密码
SystemConstant.passwordOfSSH=zookeeper
#Optional
SystemConstant.portOfSSH=22

5.安装配置 tomcat，修改catalina.sh

powershell 复制代码 
#指向配置文件所在的位置
JAVA_OPTS=-DconfigFilePath="/home/zookeeper/taokeeper-monitortomcat/webapps/ROOT/conf/taokeeper-monitor-config.properties

6.部署工程启动

相关推荐
CodingBrother2 小时前
Kafka简单实践
分布式·kafka
不太灵光的程序员2 小时前
【HBase分布式数据库】第七章 数据的导入导出 importtsv导入数据
数据库·分布式·hbase
Acrel_WPP4 小时前
分布式光伏智慧平台建设现场 系统集成商如何盈利
分布式
大山同学4 小时前
DPGO:异步和并行分布式位姿图优化 2020 RA-L best paper
人工智能·分布式·语言模型·去中心化·slam·感知定位
Lyqfor5 小时前
云原生学习
java·分布式·学习·阿里云·云原生
流雨声5 小时前
2024-09-01 - 分布式集群网关 - LoadBalancer - 阿里篇 - 流雨声
分布式
floret*6 小时前
用pyspark把kafka主题数据经过etl导入另一个主题中的有关报错
分布式·kafka·etl
william8236 小时前
Information Server 中共享开源服务中 kafka 的__consumer_offsets目录过大清理
分布式·kafka·开源
P.H. Infinity7 小时前
【RabbitMQ】10-抽取MQ工具
数据库·分布式·rabbitmq
Hsu_kk9 小时前
Kafka 安装教程
大数据·分布式·kafka
热门推荐
01玄机平台应急响应—webshell查杀02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04新版微信小程序获取用户手机号05文件或文件夹名称中有空格如何批量去除06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07【TC3xx芯片】TC3xx芯片电源管理系统PMS详解08优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10智能车联网安全发展形势、挑战