说明：本文为读《从Paxos到Zookeeper 分布式一致性原理与实践》读书笔记
shell操作
Java客户端
原始API
pom文件：
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.4.10</version>
</dependency>
Java代码：
public class ZkClientUtil {
private static final Logger logger = LoggerFactory.getLogger(ZkDemo.class);
private static ZooKeeper zk;
// /zfpt 必须提前创建好
private static String zkPath = "master:2181,slave1:2181,slave2:2181/zfpt" ;
static CountDownLatch connectedSemaphore = new CountDownLatch( 1 );
static {
try {
zk = new ZooKeeper(zkPath, 1000 , new Watcher() {
// 监控所有被触发的事件
public void process(WatchedEvent event) {
logger.info("已经触发了 {} 事件！ ", event.getType());
connectedSemaphore.countDown();
}
});
}catch (Exception e) {
System.err.println("系统异常");
}
}
public static ZooKeeper getZKConnection() {
try {
if (zk == null) {
connectedSemaphore.await();
}
return zk ;
}catch (Exception e) {
System.err.printf("ZK初始化失败");
}
return null ;
}
}
/**
* 相应操作
*/
public class ZkDemoTest {
/**
* 同步创建 zk节点
* @throws Exception
*/
@Test
public void create() throws Exception {
String response = getZKConnection().create("/aa3","test".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
System.out.println(response) ;
}
/**
* 异步回调创建 zk节点
* @throws Exception
*/
@Test
public void createASync() throws Exception {
CountDownLatch countDownLatch = new CountDownLatch(1) ;
//StringCallback 异步回调 ctx:用于传递给回调方法的一个参数。通常是放一个上下文(Context)信息
getZKConnection().create("/aa2", "test".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL, (rc, path, ctx, name) -> {
System.out.println("rc:" + rc + "&path:" + path + "&ctx:" + ctx + "&name:" + name );
countDownLatch.countDown();
},"1212121");
countDownLatch.await();
}
/**
* 同步删除
* @throws Exception
*/
@Test
public void delete() throws Exception {
// version 表示此次删除针对于的版本号。 传-1 表示忽略版本号
getZKConnection().delete("/aa1",-1);
}
/**
* 异步删除
* @throws Exception
*/
@Test
public void deleteASync() throws Exception {
CountDownLatch countDownLatch = new CountDownLatch(1) ;
getZKConnection().delete("/aa1",-1, (rc, path, ctx) -> {
System.out.println("rc:" + rc +"&path:" + path + "&ctx:" + ctx);
countDownLatch.countDown();
},"删除操作");
countDownLatch.await();
}
/**
* 同步获取数据，包括子节点列表的获取和当前节点数据的获取
* @throws Exception
*/
@Test
public void getChildren() throws Exception {
Stat stat = new Stat() ;
// path:指定数据节点的节点路径， 即API调用的目的是获取该节点的子节点列表，但不包括孙子节点
// Watcher : 注册的Watcher。一旦在本次获取子节点之后，子节点列表发生变更的话，就会向该Watcher发送通知。Watcher仅会被触发一次。
// state: 获取指定数据节点(也就是path参数对应的节点)的状态信息(无节点名和数据内容)，传入旧的state将会被来自服务端响应的新state对象替换。
List<String> list = ZkClientUtil.getZKConnection().getChildren("/", event -> {
System.out.println("我是监听事件，监听子节点变化");
} ,stat);
System.out.println(list);
System.out.println(stat);
}
/**
* 异步获取子节点
* @throws Exception
*/
@Test
public void getChildrenASync() throws Exception {
CountDownLatch countDownLatch = new CountDownLatch(1) ;
ZkClientUtil.getZKConnection().getChildren("/",event -> {
System.out.println("我是监听事件，监听子节点变化");
} , (rc, path, ctx, children) -> {
//异步回调
System.out.println("children:" + children);
countDownLatch.countDown();
},"context");
countDownLatch.await();
}
/**
* 同步获取数据
* @throws Exception
*/
@Test
public void getDataTest() throws Exception {
Stat stat = new Stat() ;
byte[] bytes = ZkClientUtil.getZKConnection().getData("/aa1",event -> {
System.out.println("我是监听事件，监听数据状态发生变化");
},stat);
System.out.println(new String(bytes));
}
@Test
public void getDataASync() throws Exception {
CountDownLatch countDownLatch = new CountDownLatch(1) ;
ZkClientUtil.getZKConnection().getData("/aa1",event -> {
System.out.println("我是监听事件，监听数据状态发生变化");
}, (rc, path, ctx, data, stat) -> {
System.out.println("获取到的内容是："+new String(data));
countDownLatch.countDown();
},"121");
countDownLatch.await();
}
/**
* 同步更新数据
*/
@Test
public void setData() throws Exception{
byte[] oldValue = ZkClientUtil.getZKConnection().getData("/aa1",false,null);
System.out.println("更新前值是:" + new String(oldValue));
Stat stat = ZkClientUtil.getZKConnection().setData("/aa1","helloWorld".getBytes(),-1);
byte[] newValue = ZkClientUtil.getZKConnection().getData("/aa1",false,null);
System.out.println("更新后值是:" + new String(newValue));
}
/**
* 异步更新数据
* @throws Exception
*/
@Test
public void setDataASync() throws Exception {
CountDownLatch countDownLatch = new CountDownLatch(1) ;
ZkClientUtil.getZKConnection().setData("/aa1","helloChina".getBytes(),-1, (rc, path, ctx, name) -> {
System.out.println("更新成功");
countDownLatch.countDown();
},"1111");
countDownLatch.await();
byte[] newValue = ZkClientUtil.getZKConnection().getData("/aa1",false,null);
System.out.println("更新前值是:" + new String(newValue));
}
}
使用ZkClient客户端
pom.xml
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>3.4.10</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.101tec/zkclient -->
<dependency>
<groupId>com.101tec</groupId>
<artifactId>zkclient</artifactId>
<version>0.10</version>
</dependency>
创建节点：
public class ZKClientTest {
private static final String zkPath = "master:2181,slave1:2181,slave2:2181/zfpt";
private static ZkClient zkClient = null;
@Before
public void init() {
zkClient = new ZkClient(zkPath,10000,10000);
}
@Test
public void create() {
// 创建节点
String result = zkClient.create("/aa3","test", CreateMode.EPHEMERAL);
System.out.println(result);
// 递归创建
zkClient.createPersistent("/trade/open",true);
// 注意不要写成这种，API的问题，这种无法递归创建
// zkClient.createPersistent("/trade/open",true);
}
}
相比原始API，ZkClient创建Znode的特性：
- 支持同步创建。
- 更丰富更简单的序列化方式，原始的只能传递byte[]数组。
- 更简便的API，
createPersistent和createEphemeral等。 - 支持递归创建。
删除接口：
@Test
public void delete() {
// 递归删除
Boolean results = zkClient.deleteRecursive("/trade");
System.out.println("删除结果:" + results);
}
特性：
- 递归删除。原始ZooKeeper只支持删除叶子节点。ZkClient支持层级遍历递归删除。
读取子节点：
/**
* 获取子节点
*/
@Test
public void getChildren() {
List<String> childrenList = zkClient.getChildren("/trade");
System.out.println(childrenList);
}
获取节点数据：
@Test
public void readData() {
String data = zkClient.readData("/trade");
System.out.println(data);
}
更新数据：
@Test
public void setData() {
String oldValue = zkClient.readData("/trade");
System.out.println("获取前:" + oldValue);
zkClient.writeData("/trade","I am trade");
String newValue = zkClient.readData("/trade");
System.out.println("更新后:" + newValue);
}
监听器：
//监听子节点变化
zkClient.subscribeChildChanges("/trade",(parentPath,currenChilds)->{
System.out.println("子节点发生变化");
});
zkClient.subscribeDataChanges("/trade",new IZkDataListener() {
@Override
public void handleDataChange(String dataPath, Object data) throws Exception {
System.out.println("dataPath:" + dataPath +"发生变化，最新数据是:" + data);
}
@Override
public void handleDataDeleted(String dataPath) throws Exception {
System.out.printf("dataPath被删除");
}
});
原生Watcher只支持一次注册，但是ZkClient的listener已经支持重复注册。
Curator
Curator在ZooKeeper原生API的基础上进行了包装，提供了一套易用性和可读性更强的Fluent风格的客户端API框架。
除此之外，Curator中还提供了ZooKeeper各种应用场景(Recipe 如共享锁服务、Master选举机制和分布式计数器等)的抽象封装。
pom.xml
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-framework</artifactId>
<version>RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.curator/curator-recipes -->
<dependency>
<groupId>org.apache.curator</groupId>
<artifactId>curator-recipes</artifactId>
<version>RELEASE</version>
</dependency>
创建节点：
@Before
public void before() {
// 非Fluent风格
// CuratorFramework curatorFramework = CuratorFrameworkFactory.newClient(zkPath, new RetryOneTime(100));
// System.out.println(curatorFramework.getState());
// curatorFramework.start();
// System.out.println(curatorFramework.getState());
// Fluent风格
curatorFramework = CuratorFrameworkFactory.builder()
.connectString("master:2181,slave1:2181,slave2:2181")
.retryPolicy(new RetryOneTime(1000)) //重试策略
.namespace("zfpt") // 命名空间
.build();
curatorFramework.start();
}
@Test
public void create() throws Exception {
// 创建一个持久化节点，初始化内容为空
curatorFramework.create().forPath("/dus");
// 创建一个持久化节点，初始化内容不为空
curatorFramework.create().forPath("/dus1","test".getBytes());
// 创建一个临时节点 初始化内容为空
curatorFramework.create().withMode(CreateMode.EPHEMERAL).forPath("/dus2");
// 创建一个临时节点，并递归创建不存在的父节点
// ZooKeeper中规定所有非叶子节点必须为持久节点。因此下面创建出来只有dus2会是临时节点。
curatorFramework.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL).forPath("/dj/dus2");
}
删除节点：
//删除一个节点
client.delete().forPath(path);
// 删除一个节点，并递归删除其所有子节点
client.delete().deletingChildrenIfNeeded().forPath(path)
// 删除一个节点，强制指定版本进行删除
client.delete().withVersion(version).forPath(path);
//删除一个节点，强制保证删除成功
client.delete().delete().guaranteed().forPath(path);
guaranteed() 保证删除失败后，Curator会在后台持续进行删除操作。
读取数据：
// 读取一个节点的数据内容
client.getData().forPath(path);
// 读取一个节点的数据内容，同时获取到该节点的stat
client.getData().storingStatIn(stat).forPath(path);
更新数据：
// 更新一个节点的数据内容
client.setData().forPath(path);
// 更新一个节点的数据内容，强制指定版本进行更新
client.setData().withVersion(version).forPath(path);
异步接口：
也就是说如果没有传入自定义线程池，就由EventThread这个线程串行处理所有的事件通知，如果传入了，则由自定义线程池去处理。
@Test
public void BackgroundCallbackTest() throws Exception{
CountDownLatch countDownLatch = new CountDownLatch(2);
curatorFramework.getData().inBackground((client,event)->{
System.out.println(Thread.currentThread().getName());
System.out.println(event);
System.out.println(client);
}).forPath("/trade");
Executor executor = Executors.newFixedThreadPool(2,new ThreadFactoryBuilder().setNameFormat("curator-%d").build() );
curatorFramework.getData().inBackground((client,event)->{
System.out.println(Thread.currentThread().getName());
System.out.println(event);
System.out.println(client);
},executor).forPath("/trade");
countDownLatch.await();
}
事件监听：
Curator引入了Cache来实现对ZooKeeper服务端事件的监听，Cache是Curator中对事件监听的包装，其对事件的监听其实可以近似看作是一个本地缓存视图和远程ZooKeeper视图的对比过程。同时Curator能够自动为开发人员处理反复注册监听，从而大大简化了原生API开发的繁琐过程。Cache分为两类监听类型：节点监听和子节点监听。
NodeCache：
NodeCache即可以用于监听指定ZooKeeper数据节点内容的变化，也能监听指定节点是否存在，如果原本节点不存在，那么Cache就会在节点被创建后出发NodeCacheListener。但是如果该数据节点被删除，那么Curator就无法再出发NodeCacheListener了。
@Test
public void NodeCacheTest() throws Exception{
// client : Curator 客户端实例 。 path: 监听节点的节点路径 。 dataIsCompressed：是否进行数据压缩
NodeCache nodeCache = new NodeCache(curatorFramework,"/trade",false);
// buildInitial：如果设置为true 则NodeCache在第一次启动的时候就会立刻从ZK上读取对应节点的数据内容 保存到Cache中。
nodeCache.start(false);
nodeCache.getListenable().addListener(()->{
System.out.println("Node data update , new data:" + new String(nodeCache.getCurrentData().getData()));
});
//******************** 监听一个不存在的节点 当节点被创建后，也会触发监听器 **********************//
// client : Curator 客户端实例 。 path: 监听节点的节点路径 。 dataIsCompressed：是否进行数据压缩
NodeCache nodeCache2 = new NodeCache(curatorFramework,"/trade1",false);
// buildInitial：如果设置为true 则NodeCache在第一次启动的时候就会立刻从ZK上读取对应节点的数据内容 保存到Cache中。
nodeCache2.start(false);
nodeCache2.getListenable().addListener(()->{
System.out.println("Node data update , new data:" + new String(nodeCache.getCurrentData().getData()));
});
Thread.sleep(Integer.MAX_VALUE);
}
PathChildrenCache：
用于监听指定ZooKeeper数据节点的子节点变化情况。当指定节点的子节点发生变化时，就会回调该方法。PathChildrenCacheEvent类中定义了所有的事件类型，主要包括新增子节点(CHILD_ADDED)、子节点数据变更(CHILD_UPDATED)和子节点删除(CHILD_REMOVED)三类。但是该数据节点的变化不会被此监听器监听到。无法监听孙子节点的变更。
@Test
public void PathChildrenCacheTest() throws Exception {
PathChildrenCache nodeCache = new PathChildrenCache(curatorFramework,"/trade",true);
// buildInitial：如果设置为true 则NodeCache在第一次启动的时候就会立刻从ZK上读取对应节点的数据内容 保存到Cache中。
nodeCache.start();
nodeCache.getListenable().addListener((client , event)->{
switch (event.getType()) {
case CHILD_ADDED :
System.out.println("新增子节点,数据内容是" + new String(event.getData().getData())); break;
case CHILD_UPDATED:
System.out.println("子节点被更新,数据内容是" + new String(event.getData().getData())); break;
case CHILD_REMOVED:
System.out.println("删除子节点,数据内容是" + new String(event.getData().getData())); break;
default: break;
}
});
curatorFramework.create().withMode(CreateMode.PERSISTENT).forPath("/trade/PathChildrenCache","new".getBytes());
Thread.sleep(100L);
curatorFramework.setData().forPath("/trade/PathChildrenCache","update".getBytes());
Thread.sleep(100L);
curatorFramework.delete().withVersion(-1).forPath("/trade/PathChildrenCache");
}
Master选举：
在分布式系统中，经常会碰到这样的场景：对于一个复杂的任务，仅需要从集群中选举出一台进行处理即可。诸如此类的分布式问题，我们统称为“Master选举”。借助于ZooKeeper，我们可以比较方便地实现Master选举的功能，其大体思路非常简单：
选择一个根节点，例如/master_select，多台机器同时向该节点创建一个子节点/master_select/lock，利用ZooKeeper的特性，最终只有一台机器能够创建成功，成功的那台机器就作为Master。
Curator也是基于这个思路，但是它将节点创建、事件监听和自动选举过程进行了封装，开发人员只需要调用简单的API即可实现Master选举。
@Test
public void leaderSelector() throws Exception {
AtomicInteger masterCount = new AtomicInteger(0);
ExecutorService executor = Executors.newFixedThreadPool(4,new ThreadFactoryBuilder().setNameFormat("master_selector-%d").build() );
for( int i = 0 ; i < 4; i++) {
executor.execute(()-> {
LeaderSelector leaderSelector = new LeaderSelector(curatorFramework, "/master_selector", new LeaderSelectorListenerAdapter() {
@Override
public void takeLeadership(CuratorFramework curatorFramework) throws Exception {
masterCount.incrementAndGet();
System.out.println(Thread.currentThread().getName() + "成为Master, 当前Master数量：" + masterCount);
Thread.sleep(1000L);
System.out.println(Thread.currentThread().getName() + "宕机，失去Master角色，剩下master数量：" + masterCount.decrementAndGet());
}
});
leaderSelector.autoRequeue();
leaderSelector.start();
});
}
Thread.sleep(Integer.MAX_VALUE);
}
分布式锁：
为了保证数据的一致性，临界资源加锁，保持有序访问。
/**
* 观察 Lock【n】 抢到锁 和 Lock【n】 释放锁 是不是成对出现。 如果不是，则说明有重复加锁的
* @throws Exception
*/
@Test
public void InterProcessMutex() throws Exception {
InterProcessMutex lock = new InterProcessMutex(curatorFramework,"/trade/mylock") ;
for (int i = 0 ; i < 100 ; i++) {
Thread currentThread = new Thread(() -> {
try {
// 加锁
lock.acquire();
System.out.println(Thread.currentThread().getName() + " 抢到锁");
}catch (Exception e) {
} finally {
try {
System.out.println(Thread.currentThread().getName() + " 释放锁");
// 释放锁
lock.release();
} catch (Exception e) {
e.printStackTrace();
}
}
});
currentThread.setName("Lock【" + i + "】");
currentThread.start();
}
Thread.sleep(Integer.MAX_VALUE);
}
分布式计数器：
@Test
public void DistributedAtomicInteger() throws Exception {
DistributedAtomicInteger distributedAtomicInteger = new DistributedAtomicInteger(curatorFramework,"/trade/PathChildrenCache", new RetryNTimes(1000,3)) ;
System.out.println(distributedAtomicInteger.increment().postValue());
}
分布式Barrier:
与CyClicBarrir同样的语义。
/**
* 没有定义成员数量。直接通过removeBarrier();释放屏障
* @throws Exception
*/
@Test
public void barrier() throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(4,new ThreadFactoryBuilder().setNameFormat("barrier-%d").build() );
for( int i = 0 ; i < 4; i++) {
executor.execute(()-> {
CuratorFramework client = CuratorFrameworkFactory.builder()
.connectString("master:2181,slave1:2181,slave2:2181")
.retryPolicy(new RetryOneTime(1000)) //重试策略
.namespace("zfpt") // 命名空间
.build();
client.start();
distributedBarrier = new DistributedBarrier(curatorFramework,"/trade/PathChildrenCache") ;
System.out.println(Thread.currentThread().getName() + "到达Barrier前");
try {
distributedBarrier.setBarrier();
distributedBarrier.waitOnBarrier();
System.out.println(Thread.currentThread().getName() + "越过屏障");
} catch (Exception e) {
e.printStackTrace();
}
});
}
Thread.sleep(3000L);
distributedBarrier.removeBarrier();
}
/**
* 定义成员数量，到齐了就 越过屏障
* @throws Exception
*/
@Test
public void barrier2() throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(4,new ThreadFactoryBuilder().setNameFormat("barrier-%d").build() );
for( int i = 0 ; i < 4; i++) {
executor.execute(()-> {
CuratorFramework client = CuratorFrameworkFactory.builder()
.connectString("master:2181,slave1:2181,slave2:2181")
.retryPolicy(new RetryOneTime(1000)) //重试策略
.namespace("zfpt") // 命名空间
.build();
client.start();
DistributedDoubleBarrier distributedDoubleBarrier = new DistributedDoubleBarrier(client,"/trade/PathChildrenCache",4) ;
try {
Thread.sleep(1000L);
System.out.println(Thread.currentThread().getName() + "到达Barrier前");
distributedDoubleBarrier.enter();
System.out.println(Thread.currentThread().getName() + "越过屏障");
Thread.sleep(1000L);
distributedDoubleBarrier.leave();
System.out.println(Thread.currentThread().getName() + "已经离开");
} catch (Exception e) {
e.printStackTrace();
}
});
}
Thread.sleep(Integer.MAX_VALUE);
}