zookeeper
目录
zookeeper
1.1 下载安装
1、环境准备
2、上传
3、解压
1.2 配置启动
1、配置zoo.cfg
2、Zookeeper 服务端常用命令
3、Zookeeper 客户端常用命令
2.1 ZooKeeper提供了什么
3.1 使用Java API操作zookeeper
3.2Curator API 常用操作 - Watch事件监听
4.1 分布式锁实现
Curator实现分布式锁API
InterProcessSemaphoreMutex（分布式排它锁，非可重入锁）：
InterProcessMutex（分布式可重入排它锁）：
InterProcessReadWriteLock（分布式读写锁）：
InterProcessMultiLock（多锁容器）：
InterProcessSemaphoreV2（共享信号量）：
ZooKeeper分布式锁原理
布式锁案例 – 模拟12306售票
5.1 ZooKeeper 集群搭建
Leader选举：
Zookeeper 集群角色
zookeeper
是一个分布式服务框架，是Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理等。简单来说zookeeper=文件系统+监听通知机制。
1.1 下载安装
1、环境准备
ZooKeeper服务器是用Java创建的，它运行在JVM之上。需要安装JDK 7或更高版本。
2、上传
将下载的ZooKeeper放到/opt/ZooKeeper目录下
#上传zookeeper alt+p
put f:/setup/apache-zookeeper-3.5.6-bin.tar.gz
#打开 opt目录
cd /opt
#创建zooKeeper目录
mkdir zooKeeper
#将zookeeper安装包移动到 /opt/zooKeeper
mv apache-zookeeper-3.5.6-bin.tar.gz /opt/zookeeper/
3、解压
将tar包解压到/opt/zookeeper目录下
tar -zxvf apache-ZooKeeper-3.5.6-bin.tar.gz
1.2 配置启动
1、配置zoo.cfg
进入到conf目录拷贝一个zoo_sample.cfg并完成配置
#进入到conf目录
cd /opt/zooKeeper/apache-zooKeeper-3.5.6-bin/conf/
#拷贝
cp zoo_sample.cfg zoo.cfg
修改zoo.cfg
#打开目录
cd /opt/zooKeeper/
#创建zooKeeper存储目录
mkdir zkdata
#修改zoo.cfg
vim /opt/zooKeeper/apache-zooKeeper-3.5.6-bin/conf/zoo.cfg
配置说明
- tickTime：这个时间是作为 Zookeeper 服务器之间或客户端与服务器之间维持心跳的时间间隔，也就是每个 tickTime 时间就会发送一个心跳。
- initLimit：这个配置项是用来配置 Zookeeper 接受客户端（这里所说的客户端不是用户连接 Zookeeper 服务器的客户端，而是 Zookeeper 服务器集群中连接到 Leader 的 Follower 服务器）初始化连接时最长能忍受多少个心跳时间间隔数。当已经超过 10个心跳的时间（也就是 tickTime）长度后 Zookeeper 服务器还没有收到客户端的返回信息，那么表明这个客户端连接失败。总的时间长度就是 10*2000=20 秒
- syncLimit：这个配置项标识 Leader 与 Follower 之间发送消息，请求和应答时间长度，最长不能超过多少个 tickTime 的时间长度，总的时间长度就是 5*2000=10秒
- dataDir：顾名思义就是 Zookeeper 保存数据的目录，默认情况下，Zookeeper 将写数据的日志文件也保存在这个目录里。
- clientPort：这个端口就是客户端连接 Zookeeper 服务器的端口，Zookeeper 会监听这个端口，接受客户端的访问请求。
- server.A=B：C：D：其中 A 是一个数字，表示这个是第几号服务器；B 是这个服务器的 ip 地址；C 表示的是这个服务器与集群中的 Leader 服务器交换信息的端口；D 表示的是万一集群中的 Leader 服务器挂了，需要一个端口来重新进行选举，选出一个新的 Leader，而这个端口就是用来执行选举时服务器相互通信的端口。如果是伪集群的配置方式，由于 B 都是一样，所以不同的 Zookeeper 实例通信端口号不能一样，所以要给它们分配不同的端口号。
2、Zookeeper 服务端常用命令
• 启动 ZooKeeper 服务 : ./zkServer.sh start
• 查看 ZooKeeper 服务状态 : ./zkServer.sh status
• 停止 ZooKeeper 服务 : ./zkServer.sh stop
• 重启 ZooKeeper 服务 : ./zkServer.sh restart
3、Zookeeper 客户端常用命令
节点信息
2.1 ZooKeeper提供了什么
- 文件系统
- Zookeeper是一个树形目录服务,其数据模型和Unix的文件系统目录树很类似，拥有一个层次化结构，提供一个多层级的节点命名空间（节点称为znode）。与文件系统不同的是，这些节点都可以设置关联的数据（每个节点上都会保存自己的数据和节点信息），而文件系统中只有文件节点可以存放数据而目录节点不行。Zookeeper为了保证高吞吐和低延迟，在内存中维护了这个树状的目录结构，这种特性使得Zookeeper不能用于存放大量的数据，每个节点的存放数据上限为1M。
- 通知机制
- client端会对某个znode建立一个watcher事件，当该znode发生变化时（数据改变、被删除、子目录节点增加删除）时，这些client会收到zk的通知，然后client可以根据znode变化来做出业务上的改变等。
3.1 使用Java API操作zookeeper
Curator 是 Apache ZooKeeper 的Java客户端库。
在服务器上一定要关闭防火墙 或者 对2128端口进行放行（踩过的大坑
常见的ZooKeeper Java API ：
• 原生 Java API
• ZkClient
• Curator
org.apache.curator
curator-framework
4.0.0
org.apache.curator
curator-recipes
4.0.0
log4j.properties
log4j.rootLogger=off,stdout
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%d{yyyy-MM-dd HH/:mm/:ss}]%-5p %c(line/:%L) %x-%m%npackage com.itheima.curator;
import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.api.BackgroundCallback;
import org.apache.curator.framework.api.CuratorEvent;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.data.Stat;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.List;
public class CuratorTest {
private CuratorFramework client;
/**
* 建立连接
*/
@BeforeEach
public void testConnect() throws Exception{
/*
*
* @param connectString 连接字符串。zk server 地址和端口 "192.168.149.135:2181,192.168.149.136:2181"
* @param sessionTimeoutMs 会话超时时间 单位ms
* @param connectionTimeoutMs 连接超时时间 单位ms
* @param retryPolicy 重试策略
*/
// /* //重试策略
// RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000,10);
// //1.第一种方式
// CuratorFramework client = CuratorFrameworkFactory.newClient("121.37.118.193:2181",
// 60 * 1000, 15 * 1000, retryPolicy);
//重试策略
RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 10);
// //2.第二种方式
// //CuratorFrameworkFactory.builder();
client = CuratorFrameworkFactory.builder()
.connectString("121.37.118.193:2181")
.sessionTimeoutMs(60 * 1000)
.connectionTimeoutMs(15 * 1000)
.retryPolicy(retryPolicy)
.namespace("itheima")
.build();
//
// //开启连接
client.start();
// System.out.println(client.getConfig().toString());
}
//==============================create=============================================================================
/**
* 创建节点：create 持久 临时 顺序 数据
* 1. 基本创建 ：create().forPath("")
* 2. 创建节点 带有数据:create().forPath("",data)
* 3. 设置节点的类型：create().withMode().forPath("",data)
* 4. 创建多级节点 /app1/p1 ：create().creatingParentsIfNeeded().forPath("",data)
*/
@Test
public void testCreate() throws Exception {
//2. 创建节点 带有数据
//如果创建节点，没有指定数据，则默认将当前客户端的ip作为数据存储
String path = client.create().forPath("/app2", "hehe".getBytes());
System.out.println(path);
}
@Test
public void testCreate2() throws Exception {
//1. 基本创建
//如果创建节点，没有指定数据，则默认将当前客户端的ip作为数据存储
String path = client.create().forPath("/app1");
System.out.println(path);
}
@Test
public void testCreate3() throws Exception {
//3. 设置节点的类型
//默认类型：持久化
String path = client.create().withMode(CreateMode.EPHEMERAL).forPath("/app3");
System.out.println(path);
}
@Test
public void testCreate4() throws Exception {
//4. 创建多级节点 /app1/p1
//creatingParentsIfNeeded():如果父节点不存在，则创建父节点
String path = client.create().creatingParentsIfNeeded().forPath("/app4/p1");
System.out.println(path);
}
//===========================get================================================================================
/**
* 查询节点：
* 1. 查询数据：get: getData().forPath()
* 2. 查询子节点： ls: getChildren().forPath()
* 3. 查询节点状态信息：ls -s:getData().storingStatIn(状态对象).forPath()
*/
@Test
public void testGet1() throws Exception {
//1. 查询数据：get
byte[] data = client.getData().forPath("/app1");
System.out.println(new String(data));
}
@Test
public void testGet2() throws Exception {
// 2. 查询子节点： ls
List path = client.getChildren().forPath("/");
System.out.println(path);
}
@Test
public void testGet3() throws Exception {
Stat status = new Stat();
System.out.println(status);
//3. 查询节点状态信息：ls -s
client.getData().storingStatIn(status).forPath("/app1");
System.out.println(status);
}
//===========================set================================================================================
/**
* 修改数据
* 1. 基本修改数据：setData().forPath()
* 2. 根据版本修改: setData().withVersion().forPath()
* * version 是通过查询出来的。目的就是为了让其他客户端或者线程不干扰我。
*
* @throws Exception
*/
@Test
public void testSet() throws Exception {
client.setData().forPath("/app1", "itcast".getBytes());
}
@Test
public void testSetForVersion() throws Exception {
Stat status = new Stat();
//3. 查询节点状态信息：ls -s
client.getData().storingStatIn(status).forPath("/app1");
int version = status.getVersion();//查询出来的 3
System.out.println(version);
client.setData().withVersion(version).forPath("/app1", "hehe".getBytes());
}
//===========================delete================================================================================
/**
* 删除节点： delete deleteall
* 1. 删除单个节点:delete().forPath("/app1");
* 2. 删除带有子节点的节点:delete().deletingChildrenIfNeeded().forPath("/app1");
* 3. 必须成功的删除:为了防止网络抖动。本质就是重试。 client.delete().guaranteed().forPath("/app2");
* 4. 回调：inBackground
* @throws Exception
*/
@Test
public void testDelete() throws Exception {
// 1. 删除单个节点
client.delete().forPath("/app1");
}
@Test
public void testDelete2() throws Exception {
//2. 删除带有子节点的节点
client.delete().deletingChildrenIfNeeded().forPath("/app4");
}
@Test
public void testDelete3() throws Exception {
//3. 必须成功的删除
client.delete().guaranteed().forPath("/app2");
}
@Test
public void testDelete4() throws Exception {
//4. 回调
client.delete().guaranteed().inBackground(new BackgroundCallback(){
@Override
public void processResult(CuratorFramework client, CuratorEvent event) throws Exception {
System.out.println("我被删除了~");
System.out.println(event);
}
}).forPath("/app1");
}
@AfterEach
public void close() {
if (client != null) {
client.close();
}
System.out.println("22222");
}
}
3.2Curator API 常用操作 - Watch事件监听
- ZooKeeper 允许用户在指定节点上注册一些Watcher，并且在一些特定事件触发的时候，ZooKeeper 服务端会将事件通知到感兴趣的客户端上去，该机制是 ZooKeeper 实现分布式协调服务的重要特性。
- ZooKeeper 中引入了Watcher机制来实现了发布/订阅功能能，能够让多个订阅者同时监听某一个对象，当一个对象自身状态变化时，会通知所有订阅者。
- ZooKeeper 原生支持通过注册Watcher来进行事件监听，但是其使用并不是特别方便
- 需要开发人员自己反复注册Watcher，比较繁琐。
- Curator引入了 Cache 来实现对 ZooKeeper 服务端事件的监听。
- ZooKeeper提供了三种Watcher：
- NodeCache : 只是监听某一个特定的节点
- PathChildrenCache : 监控一个ZNode的子节点.
- TreeCache : 可以监控整个树上的所有节点，类似于PathChildrenCache和NodeCache的组合
/**
* 演示 NodeCache：给指定一个节点注册监听器
*/
@Test
public void testNodeCache() throws Exception {
//1. 创建NodeCache对象
final NodeCache nodeCache = new NodeCache(client,"/app1");
//2. 注册监听
nodeCache.getListenable().addListener(new NodeCacheListener() {
@Override
public void nodeChanged() throws Exception {
System.out.println("节点变化了~");
//获取修改节点后的数据
byte[] data = nodeCache.getCurrentData().getData();
System.out.println(new String(data));
}
});
//3. 开启监听.如果设置为true，则开启监听是，加载缓冲数据
nodeCache.start(true);
while (true){
}
}
/**
* 演示 PathChildrenCache：监听某个节点的所有子节点们
*/
@Test
public void testPathChildrenCache() throws Exception {
//1.创建监听对象
PathChildrenCache pathChildrenCache = new PathChildrenCache(client,"/app2",true);
//2. 绑定监听器
pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
@Override
public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) throws Exception {
System.out.println("子节点变化了~");
System.out.println(event);
//监听子节点的数据变更，并且拿到变更后的数据
//1.获取类型
PathChildrenCacheEvent.Type type = event.getType();
//2.判断类型是否是update
if(type.equals(PathChildrenCacheEvent.Type.CHILD_UPDATED)){
System.out.println("数据变了！！！");
byte[] data = event.getData().getData();
System.out.println(new String(data));
}
}
});
//3. 开启
pathChildrenCache.start();
while (true){
}
}
/**
* 演示 TreeCache：监听某个节点自己和所有子节点们
*/
@Test
public void testTreeCache() throws Exception {
//1. 创建监听器
TreeCache treeCache = new TreeCache(client,"/app2");
//2. 注册监听
treeCache.getListenable().addListener(new TreeCacheListener() {
@Override
public void childEvent(CuratorFramework client, TreeCacheEvent event) throws Exception {
System.out.println("节点变化了");
System.out.println(event);
}
});
//3. 开启
treeCache.start();
while (true){
}
}
4.1 分布式锁实现
Curator实现分布式锁API
InterProcessSemaphoreMutex（分布式排它锁，非可重入锁）：
这是一种排他锁，用于确保在分布式环境中只有一个线程能够获取锁并访问共享资源。与Java中的普通锁不同，这种锁不支持可重入，意味着一个线程在持有锁的情况下不能再次获取相同的锁。
- 场景：适用于需要保护临界区，但不支持同一个线程多次获取锁的情况。
- 类比：一个厕所的门锁，只有一个人可以进去，进去后锁上，其他人必须等待。
InterProcessSemaphoreMutexlock = new InterProcessSemaphoreMutex(client, "/lockPath");
try {
lock.acquire();
// 你的业务逻辑
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.release();
}
jInterProcessMutex（分布式可重入排它锁）：
类似于InterProcessSemaphoreMutex，这也是一种排他锁，但与之不同的是，它支持可重入。这意味着一个线程在获取锁后，仍然可以再次获取同一个锁，而不会发生死锁。
- 场景：适用于需要保护临界区，支持同一个线程多次获取锁的情况。
- 类比：家里的房间门锁，你可以进出多次，只要你拥有钥匙。
InterProcessMutex lock = new InterProcessMutex(client, "/lockPath");
try {
lock.acquire();
// 你的业务逻辑
lock.acquire(); // 可重入
// 更多业务逻辑
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.release();
lock.release(); // 可重入
}
InterProcessReadWriteLock（分布式读写锁）：
这种锁允许多个线程同时访问共享资源，但在某个线程获取写锁（排它锁）时，其他线程不能同时获取写锁或读锁。这样可以实现读写分离，提高并发性能。
- 场景：适用于读多写少的场景，允许多个线程同时读取，但只允许一个线程写入。
- 类比：图书馆的阅览区，多人可以同时阅读书籍，但只有一个人可以写下笔记。
InterProcessReadWriteLock readWriteLock = new InterProcessReadWriteLock(client, "/lockPath");
InterProcessMutex readLock = readWriteLock.readLock();
InterProcessMutex writeLock = readWriteLock.writeLock();
try {
readLock.acquire(); // 获取读锁
// 读操作
} catch (Exception e) {
e.printStackTrace();j
} finally {
readLock.release();
}
try {
writeLock.acquire(); // 获取写锁
// 写操作
} catch (Exception e) {
e.printStackTrace();
} finally {
writeLock.release();
}
InterProcessMultiLock（多锁容器）：
InterProcessMultiLock允许将多个锁作为单个实体进行管理。这对于需要同时获取多个锁的情况很有用，例如跨多个资源进行操作时，可以避免死锁问题。
- 场景：适用于需要同时操作多个资源，确保获取所有资源的顺序，避免死锁。
- 类比：假设你需要锁住两个门才能进入一个房间，你希望确保每次都是先锁门A再锁门B，避免锁的顺序问题。
- 类比：假设你正在编写一个在线多人游戏，游戏数据分散在多个服务器上。每个服务器都有一个锁，用于管理该服务器上的游戏数据。当你需要更新玩家数据时，必须同时获取多个服务器上的锁，以确保数据一致性。
InterProcessMutex lock1 = new InterProcessMutex(client, "/lockPath1");
InterProcessMutex lock2 = new InterProcessMutex(client, "/lockPath2");
List locks = Arrays.asList(lock1, lock2);
InterProcessMultiLock multiLock = new InterProcessMultiLock(locks);
try {
multiLock.acquire();
// 你的业务逻辑
} catch (Exception e) {
e.printStackTrace();
} finally {
multiLock.release();
}
InterProcessSemaphoreV2（共享信号量）：
共享信号量允许多个线程在同一时刻共享资源，但限制了同时访问资源的线程数量。与经典信号量类似，这可以用于控制资源的并发访问数量。
- 场景：适用于控制并发访问的数量，例如资源池。
- 类比：在一个游泳池里，你只允许同时有一定数量的人，当有人离开池子时，下一个人可以进入。
int maxLeases = 10; // 最大许可数
String semaphorePath = "/semaphorePath";
InterProcessSemaphoreV2 semaphore = new InterProcessSemaphoreV2(client, semaphorePath, maxLeases);
SemaphoreLease lease = semaphore.acquire();
try {
// 你的业务逻辑
} catch (Exception e) {
e.printStackTrace();
} finally {
semaphore.returnLease(lease);
}
在 Curator 中有五种锁 方案：
- InterProcessSemaphoreMutex：分布式排它锁（非可重入锁）
- InterProcessMutex：分布式可重入排它锁
- InterProcessReadWriteLock：分布式读写锁
- InterProcessMultiLock：将多个锁作为单个实体管理的容器
- InterProcessSemaphoreV2：共享信号量
跨机器的进程之间的数据同步问题——这就是分布式锁。
ZooKeeper分布式锁原理
• 核心思想： 当客户端要获取锁，则创建节点，使用完锁，则删除该节点。
1. 客户端获取锁时，在 lock 节点下创建 临时顺序 节点。
2. 然后获取lock下面的所有子节点 ，客户端 获取到所有的子 节点之后 ， 如果发现自己创建的子节点序号最小，那么就认为该客户端获取到了锁 。使用完锁后，将该节点删除。
3. 如果 发现自己创建的节点并非 lock 所有 子节点中最小的，说明自己还没有获取到锁 ， 此时客户端需要找到比自己小的那个节点 ， 同时对其注册事件监听器 ，监听删除事件。
4 .如果发现比自己小的那个节点被删除，则客户端的Watcher会收到相应通知 ，此时再次判断自己创建的 节点是否是 lock 子 节点中序号最小的，如果是则获取到了锁 ，如果不是则重复以上步骤继续获取到比自己小的一个 节点并注册监听。
布式锁案例 – 模拟12306售票
public class LockTest {
public static void main(String[] args) {
Ticket12306 ticket12306 = new Ticket12306();
//创建客户端
Thread t1 = new Thread(ticket12306,"携程");
Thread t2 = new Thread(ticket12306,"飞猪");
t1.start();
t2.start();
}
}
public class Ticket12306 implements Runnable{
private int tickets = 10;//数据库的票数
private InterProcessMutex lock ;
public Ticket12306(){
//重试策略
RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 10);
//2.第二种方式
//CuratorFrameworkFactory.builder();
CuratorFramework client = CuratorFrameworkFactory.builder()
.connectString("121.37.118.193:2181")
.sessionTimeoutMs(60 * 1000)
.connectionTimeoutMs(15 * 1000)
.retryPolicy(retryPolicy)
.build();
//开启连接
client.start();
lock = new InterProcessMutex(client,"/lock");
}
@Override
public void run() {
while(true){
//获取锁
try {
lock.acquire(3, TimeUnit.SECONDS);
if(tickets > 0){
System.out.println(Thread.currentThread()+":"+tickets);
Thread.sleep(100);
tickets--;
}
} catch (Exception e) {
e.printStackTrace();
}finally {
//释放锁
try {
lock.release();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}5.1 ZooKeeper 集群搭建
Leader选举：
• Serverid ：服务器 ID
比如有三台服务器，编号分别是1,2,3。编号越大在选择算法中的权重越大。
• Zxid ：数据 ID
服务器中存放的最大数据ID.值越大说明数据 越新，在选举算法中数据越新权重越大。
• 在 Leader 选举 的过程中，如果 某台 ZooKeeper 获得了超过半数的选票 ，则此ZooKeeper 就可以成为 Leader 了。
Zookeeper 集群角色
在ZooKeeper集群服中务中有三个角色：
• Leader 领导者 ：
1. 处理事务请求
2. 集群内部各服务器的调度者
• Follower 跟随者 ：
1. 处理客户端非事务请求，转发事务请求给Leader服务器
2. 参与Leader选举投票
• Observer 观察者 ：
1. 处理客户端非事务请求，转发事务请求给Leader服务器