zookeeper --- 高级篇

news2024/11/15 1:42:45

一、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无
NodeCreatedWatcher监听的数据节点被创建时
NodeDeletedWatcher监听的数据节点被删除时
NodeDataChangedWatcher监听的数据节点内容发生变更时(无论内容数据是否变化)
NodeChildrenChangedWatcher监听的数据节点的子节点列表发生变更时

注：客户端接收到的相关事件通知中只包含状态及类型等信息，不包括节点变化前后的具体内容，变化前的数据需业务自身存储，变化后的数据需调用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节点为例，说明调用的注册方法和可监听事件间的关系：

注册方式CreatedChildrenChangedChangedDeleted
zk.exists(“/node-x”,watcher)可监控可监控可监控
zk.getData(“/node-x”,watcher)可监控可监控
zk.getChildren(“/node-x”,watcher)可监控可监控

1.6、注册watcher的方法

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

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

1.6.2、检查节点是否存在

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

1.6.3、查看节点

// 使用连接对象的监视器
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、查看子节点

// 使用连接对象的监视器
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. 重新获取配置信息

案例:

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

案例:

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步逻辑，判断自己是否获得了锁

案例:

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();
		}
	}
}

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

[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

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

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

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

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

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列表如下

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、启动集群

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

/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

在这里插入图片描述

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

/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号，发现状态并没有变化

/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号（主服务器）的状态，发现已经停止运行了。

/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号服务器又开始正常工作了。而且依然是领导者。

/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号的状态。

/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号服务器会再次成为新的领导吗？我们看结果

/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角色的配置文件中加入如下配
    置：
peerType=observer

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

server.3=192.168.60.130:2289:3389:observer

六、zookeeperAPI连接集群

ZooKeeper(String connectionString, int sessionTimeout, Watcher watcher)
  • connectionString ： zooKeeper集合主机。
  • sessionTimeout ： 会话超时（以毫秒为单位）。
  • watcher ： 实现“监视器”界面的对象。ZooKeeper集合通过监视器对象返回连接状
    态。
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命令工具安装:

#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.下载数据库脚本

wget https://github.com/downloads/alibaba/taokeeper/taokeeper.sql

2.下载主程序

wget https://github.com/downloads/alibaba/taokeeper/taokeepermonitor.tar.gz

3.下载配置文件

wget https://github.com/downloads/alibaba/taokeeper/taokeeper-monitorconfig.propertie

4.配置 taokeeper-monitor-config.properties

#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

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

6.部署工程启动

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/840418.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【数据结构与算法】赫夫曼树

【数据结构与算法】赫夫曼树

赫夫曼树 基本介绍 给定 n 个权值作为 n 个叶子结点&#xff0c;构造一棵二叉树&#xff0c;若该树的带权路径长度&#xff08;wpl&#xff09;达到最小&#xff0c;称这样的二叉树为最优二叉树&#xff0c;也称为哈夫曼树&#xff08;Huffman Tree&#xff09;&#xff0c;还…
阅读更多...
并查集模板的应用：连通块

并查集模板的应用：连通块

一、链接 837. 连通块中点的数量 二、题目 给定一个包含 nn 个点&#xff08;编号为 1∼n1∼n&#xff09;的无向图&#xff0c;初始时图中没有边。 现在要进行 mm 个操作&#xff0c;操作共有三种&#xff1a; C a b&#xff0c;在点 aa 和点 bb 之间连一条边&#xff0c…
阅读更多...
全志F1C200S嵌入式驱动开发（soc系统集成）

全志F1C200S嵌入式驱动开发（soc系统集成）

【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 任何一个嵌入式设备都是由很多的子系统组成的。这里面有硬件、有软件，还可能有机械，并不一定就是大家看到的消费电子那样，即一个soc构成了所有的系统。现实情况是，要构建一个系…
阅读更多...
目标检测中的IOU

目标检测中的IOU

IOU 什么是IOU？IOU应用场景写代码调试什么是IOU？ 简单来说IOU就是用来度量目标检测中预测框与真实框的重叠程度。在图像分类中，有一个明确的指标准确率来衡量模型分类模型的好坏。其公式为： 这个公式显然不适合在在目标检测中使用。我们知道目标检测中都是用一个矩形框住…
阅读更多...
Selenium入门详细教程+实例演示

Selenium入门详细教程+实例演示

目录 1.Selenium概述 1.1什么是Selenium 1.2Selenium的优势 1.3Selenium WebDriver原理 2.Selenium环境搭建 3.Selenium 简单示例 4.八大元素定位 4.1定位方式 4.2定位方式的用法 5.Selenium API 5.1WebDriver 常用 API 5.2WebElement 常用 API 5.3代码示例 6.元素等待机…
阅读更多...
浏览器不同源的页面之间如何跨域通信

浏览器不同源的页面之间如何跨域通信

目录 1&#xff0c;需求2&#xff0c;难点3&#xff0c;思路浏览器不同源的页面之间如何跨域通信&#xff1f; 4&#xff0c;实现第1版第2版最终版其他的问题1&#xff0c;页面路径需完全一致。2&#xff0c;事件注册问题 1&#xff0c;需求 现在有2个项目&#xff0c;页面路径…
阅读更多...
三分钟带你快速了解MongoDB是什么及其相关基础概念

三分钟带你快速了解MongoDB是什么及其相关基础概念

文章目录 前言1. MongoDB简介2. 业务应用场景3. 体系结构4. 数据模型5. MongoDB的特点 总结 前言 为了巩固所学的知识&#xff0c;作者尝试着开始发布一些学习笔记类的博客&#xff0c;方便日后回顾。当然&#xff0c;如果能帮到一些萌新进行新技术的学习那也是极好的。作者菜…
阅读更多...
SpringBoot第31讲：SpringBoot集成ShardingJDBC - Sharding-JDBC简介和基于MyBatis的单库分表

SpringBoot第31讲：SpringBoot集成ShardingJDBC - Sharding-JDBC简介和基于MyBatis的单库分表

SpringBoot第31讲&#xff1a;SpringBoot集成ShardingJDBC - Sharding-JDBC简介和基于MyBatis的单库分表 本文是SpringBoot第31讲&#xff0c;主要介绍分表分库&#xff0c;以及SpringBoot集成基于ShardingJDBCMyBatis的单库分表实践 文章目录 SpringBoot第31讲&#xff1a;Spr…
阅读更多...
微服务——操作索引库+文档操作+RestClient操作索引库和文档(java程序)

微服务——操作索引库+文档操作+RestClient操作索引库和文档(java程序)

索引库操作 mapping属性 mapping是对文档的约束&#xff0c;常见约束属性包括: 创建索引库 #创建索引库 PUT /heima {"mappings": {"properties": {"info":{"type": "text","analyzer": "ik_smart"},…
阅读更多...
K8s中的Controller

K8s中的Controller

Controller的作用 &#xff08;1&#xff09;确保预期的pod副本数量 &#xff08;2&#xff09;无状态应用部署 &#xff08;3&#xff09;有状态应用部署 &#xff08;4&#xff09;确保所有的node运行同一个pod&#xff0c;一次性任务和定时任务 1.无状态和有状态 无状态&…
阅读更多...
AIDL与HIDL核心概念

AIDL与HIDL核心概念

目录 一. 概述 二. 核心流程的核心理解 三. 一些术语 四. 参考样例 一. 概述 AIDL和HIDL都是主要用于跨进程通信&#xff0c;本质是Binder通信。 总体流程都是先写.aidl文件或.hal文件&#xff0c;这个文件只有接口定义哦不是实现&#xff0c;然后利用工具自动生成代码&a…
阅读更多...
MapReduce基础原理、MR与MPP区别

MapReduce基础原理、MR与MPP区别

MapReduce概述 MapReduce&#xff08;MR&#xff09;本质上是一种用于数据处理的编程模型&#xff1b;MapReduce用于海量数据的计算&#xff0c;HDFS用于海量数据的存储&#xff08;Hadoop Distributed File System&#xff0c;Hadoop分布式文件系统&#xff09;。Hadoop MapR…
阅读更多...
数据库的约束 详解

数据库的约束 详解

一、约束的概述 1.概念:约束是作用于表中字段上的规则&#xff0c;用于限制存储在表中的数据。 2&#xff0e;目的:保证数据库中数据的正确、有效性和完整性。 3.分类: 约束描述关键字非空约束限制该字段的数据不能为nullNOT NULL唯一约束保证该字段的所有数据都是唯一、不…
阅读更多...
uni-app uView自定义底部导航栏

uni-app uView自定义底部导航栏

因项目需要自定义底部导航栏&#xff0c;我把它写在了组件里&#xff0c;基于uView2框架写的&#xff08;vue2&#xff09;&#xff1b; 一、代码 在components下创建tabbar.vue文件&#xff0c;代码如下&#xff1a; <template><view><u-tabbar :value"c…
阅读更多...
DALLE2论文解读及实现(一)

DALLE2论文解读及实现(一)

DALLE2: Hierarchical Text-Conditional Image Generation with CLIP Latents paper: https://cdn.openai.com/papers/dall-e-2.pdf github: https://github.com/lucidrains/DALLE2-pytorch DALLE2概览&#xff1a; - CLIP模型&#xff1a; 用于生成text embedding zt 和image …
阅读更多...
CentOS 搭建 Harbor 镜像仓库（图文详解）

CentOS 搭建 Harbor 镜像仓库（图文详解）

本文目录 1. 下载 Harbor 安装包2. 解压3. 修改配置文件4. 安装 Harbor5. 修改 docker 配置6. docker 登录方式7. 访问 Harbor Web 界面8. 创建证书9. 生成证书10. 更新配置11. 网页登录 说明&#xff1a;在搭建 Harbor 镜像仓库之前&#xff0c;虚拟机要先安装 docker 和 dock…
阅读更多...
123.买卖股票的最佳时机3

123.买卖股票的最佳时机3

目录 一、题目 二、分析代码 一、题目 123. 买卖股票的最佳时机 III - 力扣&#xff08;LeetCode&#xff09; 二、分析代码 class Solution { public:int maxProfit(vector<int>& prices) {//0表示没有操作//1表示第1次买入&#xff0c;2表示第1次卖出//3表示第2…
阅读更多...
Blazor前后端框架Known-V1.2.10

Blazor前后端框架Known-V1.2.10

V1.2.10 Known是基于C#和Blazor开发的前后端分离快速开发框架&#xff0c;开箱即用&#xff0c;跨平台&#xff0c;一处代码&#xff0c;多处运行。 Gitee&#xff1a; https://gitee.com/known/KnownGithub&#xff1a;https://github.com/known/Known 概述 基于C#和Blazo…
阅读更多...
LeetCode 42. 接雨水（动态规划 / 单调栈）

LeetCode 42. 接雨水（动态规划 / 单调栈）

题目&#xff1a; 链接&#xff1a;LeetCode 42. 接雨水 难度&#xff1a;困难 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图&#xff0c;计算按此排列的柱子&#xff0c;下雨之后能接多少雨水。 示例 1&#xff1a; 输入&#xff1a;height [0,1,0,2,1,0,1,3,2,1,2…
阅读更多...
【Spring Cloud 六】Hystrix熔断

【Spring Cloud 六】Hystrix熔断

这里写目录标题 系列文章目录背景一、Hystrix是什么服务雪崩服务容错的相关概念熔断器降级超时控制限流 二、会什么要有Hystrix三、如何使用Hystrix进行熔断处理整体项目代码服务提供者pom文件yml配置文件启动类controller 服务消费者pom文件yml配置文件启动类feignhystrixcont…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023