1.zookeeper实现分布式锁的作用是什么?
2.ZooKeeper分布式锁的思路是什么?
3.ZooKeeper锁不安全,该如何解决?
4.你是否有实现ZooKeeper锁的思路?
场景描述
在分布式应用, 往往存在多个进程提供同一服务. 这些进程有可能在相同的机器上, 也有可能分布在不同的机器上. 如果这些进程共享了一些资源, 可能就需要分布式锁来锁定对这些资源的访问.
本文将介绍如何利用zookeeper实现分布式锁.
思路
进程需要访问共享
数据时, 就在"/locks"节点下创建一个sequence类型的子节点, 称为thisPath. 当thisPath在所有子节点中最小时, 说明该进程获得了锁. 进程获得锁之后, 就可以访问共享资源了. 访问完成后, 需要将thisPath删除. 锁由新的最小的子节点获得.
有了清晰的思路之后, 还需要补充一些细节. 进程如何知道thisPath是所有子节点中最小的呢? 可以在创建的时候, 通过getChildren方法获取子节点列表, 然后在列表中找到排名比thisPath前1位的节点, 称为waitPath, 然后在waitPath上注册监听, 当waitPath被删除后, 进程获得通知, 此时说明该进程获得了锁.
实现
以一个DistributedClient对象模拟一个进程的形式, 演示zookeeper分布式锁的实现.
- public class DistributedClient {
- // 超时时间
- private static final int SESSION_TIMEOUT = 5000;
- // zookeeper server列表
- private String hosts = "localhost:4180,localhost:4181,localhost:4182";
- private String groupNode = "locks";
- private String subNode = "sub";
-
- private ZooKeeper zk;
- // 当前client创建的子节点
- private String thisPath;
- // 当前client等待的子节点
- private String waitPath;
-
- private CountDownLatch latch = new CountDownLatch(1);
-
- /**
- * 连接zookeeper
- */
- public void connectZookeeper() throws Exception {
- zk = new ZooKeeper(hosts, SESSION_TIMEOUT, new Watcher() {
- public void process(WatchedEvent event) {
- try {
- // 连接建立时, 打开latch, 唤醒wait在该latch上的线程
- if (event.getState() == KeeperState.SyncConnected) {
- latch.countDown();
- }
-
- // 发生了waitPath的删除事件
- if (event.getType() == EventType.NodeDeleted && event.getPath().equals(waitPath)) {
- doSomething();
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- });
-
- // 等待连接建立
- latch.await();
-
- // 创建子节点
- thisPath = zk.create("/" + groupNode + "/" + subNode, null, Ids.OPEN_ACL_UNSAFE,
- CreateMode.EPHEMERAL_SEQUENTIAL);
-
- // wait一小会, 让结果更清晰一些
- Thread.sleep(10);
-
- // 注意, 没有必要监听"/locks"的子节点的变化情况
- List childrenNodes = zk.getChildren("/" + groupNode, false);
-
- // 列表中只有一个子节点, 那肯定就是thisPath, 说明client获得锁
- if (childrenNodes.size() == 1) {
- doSomething();
- } else {
- String thisNode = thisPath.substring(("/" + groupNode + "/").length());
- // 排序
- Collections.sort(childrenNodes);
- int index = childrenNodes.indexOf(thisNode);
- if (index == -1) {
- // never happened
- } else if (index == 0) {
- // inddx == 0, 说明thisNode在列表中最小, 当前client获得锁
- doSomething();
- } else {
- // 获得排名比thisPath前1位的节点
- this.waitPath = "/" + groupNode + "/" + childrenNodes.get(index - 1);
- // 在waitPath上注册监听器, 当waitPath被删除时, zookeeper会回调监听器的process方法
- zk.getData(waitPath, true, new Stat());
- }
- }
- }
-
- private void doSomething() throws Exception {
- try {
- System.out.println("gain lock: " + thisPath);
- Thread.sleep(2000);
- // do something
- } finally {
- System.out.println("finished: " + thisPath);
- // 将thisPath删除, 监听thisPath的client将获得通知
- // 相当于释放锁
- zk.delete(this.thisPath, -1);
- }
- }
-
- public static void main(String[] args) throws Exception {
- for (int i = 0; i < 10; i++) {
- new Thread() {
- public void run() {
- try {
- DistributedClient dl = new DistributedClient();
- dl.connectZookeeper();
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- }.start();
- }
-
- Thread.sleep(Long.MAX_VALUE);
- }
- }
复制代码
思考
思维缜密的朋友可能会想到, 上述的方案并不安全. 假设某个client在获得锁之前挂掉了, 由于client创建的节点是ephemeral类型的, 因此这个节点也会被删除, 从而导致排在这个client之后的client提前获得了锁. 此时会存在多个client同时访问共享资源.
如何解决这个问题呢? 可以在接到waitPath的删除通知的时候, 进行一次确认, 确认当前的thisPath是否真的是列表中最小的节点.
- // 发生了waitPath的删除事件
- if (event.getType() == EventType.NodeDeleted && event.getPath().equals(waitPath)) {
- // 确认thisPath是否真的是列表中的最小节点
- List childrenNodes = zk.getChildren("/" + groupNode, false);
- String thisNode = thisPath.substring(("/" + groupNode + "/").length());
- // 排序
- Collections.sort(childrenNodes);
- int index = childrenNodes.indexOf(thisNode);
- if (index == 0) {
- // 确实是最小节点
- doSomething();
- } else {
- // 说明waitPath是由于出现异常而挂掉的
- // 更新waitPath
- waitPath = "/" + groupNode + "/" + childrenNodes.get(index - 1);
- // 重新注册监听, 并判断此时waitPath是否已删除
- if (zk.exists(waitPath, true) == null) {
- doSomething();
- }
- }
- }
复制代码
另外, 由于thisPath和waitPath这2个成员变量会在多个线程中访问, 最好将他们声明为volatile, 以防止出现线程可见性问题.
另一种思路
下面介绍一种更简单, 但是不怎么推荐的解决方案.
每个client在getChildren的时候, 注册监听子节点的变化. 当子节点的变化通知到来时, 再一次通过getChildren获取子节点列表, 判断thisPath是否是列表中的最小节点, 如果是, 则执行资源访问逻辑.
- public class DistributedClient2 {
- // 超时时间
- private static final int SESSION_TIMEOUT = 5000;
- // zookeeper server列表
- private String hosts = "localhost:4180,localhost:4181,localhost:4182";
- private String groupNode = "locks";
- private String subNode = "sub";
-
- private ZooKeeper zk;
- // 当前client创建的子节点
- private volatile String thisPath;
-
- private CountDownLatch latch = new CountDownLatch(1);
-
- /**
- * 连接zookeeper
- */
- public void connectZookeeper() throws Exception {
- zk = new ZooKeeper(hosts, SESSION_TIMEOUT, new Watcher() {
- public void process(WatchedEvent event) {
- try {
- // 连接建立时, 打开latch, 唤醒wait在该latch上的线程
- if (event.getState() == KeeperState.SyncConnected) {
- latch.countDown();
- }
-
- // 子节点发生变化
- if (event.getType() == EventType.NodeChildrenChanged && event.getPath().equals("/" + groupNode)) {
- // thisPath是否是列表中的最小节点
- List childrenNodes = zk.getChildren("/" + groupNode, true);
- String thisNode = thisPath.substring(("/" + groupNode + "/").length());
- // 排序
- Collections.sort(childrenNodes);
- if (childrenNodes.indexOf(thisNode) == 0) {
- doSomething();
- }
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- });
-
- // 等待连接建立
- latch.await();
-
- // 创建子节点
- thisPath = zk.create("/" + groupNode + "/" + subNode, null, Ids.OPEN_ACL_UNSAFE,
- CreateMode.EPHEMERAL_SEQUENTIAL);
-
- // wait一小会, 让结果更清晰一些
- Thread.sleep(10);
-
- // 监听子节点的变化
- List childrenNodes = zk.getChildren("/" + groupNode, true);
-
- // 列表中只有一个子节点, 那肯定就是thisPath, 说明client获得锁
- if (childrenNodes.size() == 1) {
- doSomething();
- }
- }
-
- /**
- * 共享资源的访问逻辑写在这个方法中
- */
- private void doSomething() throws Exception {
- try {
- System.out.println("gain lock: " + thisPath);
- Thread.sleep(2000);
- // do something
- } finally {
- System.out.println("finished: " + thisPath);
- // 将thisPath删除, 监听thisPath的client将获得通知
- // 相当于释放锁
- zk.delete(this.thisPath, -1);
- }
- }
-
- public static void main(String[] args) throws Exception {
- for (int i = 0; i < 10; i++) {
- new Thread() {
- public void run() {
- try {
- DistributedClient2 dl = new DistributedClient2();
- dl.connectZookeeper();
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- }.start();
- }
-
- Thread.sleep(Long.MAX_VALUE);
- }
- }
复制代码
为什么不推荐这个方案呢? 是因为每次子节点的增加和删除都要
广播给所有client, client数量不多时还看不出问题. 如果存在很多client, 那么就可能导致广播风暴--过多的广播通知阻塞了网络. 使用第一个方案, 会使得通知的数量大大下降. 当然第一个方案更复杂一些, 复杂的方案同时也意味着更容易引进bug.
浅析
创建连接:
1.获取服务主机列表
2.设置超时时间
3.注册客户端事件
4.以线程安全的方式创建请求连接(启动客户端请求队列,循环队列基于socket通信、根据请求类型执行不同的请求动作)
请求流程:
构造请求头、构造request,reponse、构造响应头、构造Packet对象,packet对象准备好后,把整个对象放入一个outgoingQueue
packet被放入outgoingQueue中,等待SendThread把packet对应的内容发送给server。server处理分3步在doio方法中ReadLength ReadConnectResult ReadResponse,直到ReadResponse方法中确定packet请求结束。
响应流程:
针对心跳的ping请求的resp,针对auth请求的resp,一般接口请求的resp,如果接口请求要求了watcher,当watcher关注的内容有变化时的notification
锁相关部分API方法:
创建节点:create
demo:zk.Create(Dir, severname.GetBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.Persistent);
其中CreateMode分为4类Persistent、PersistentSequential、Ephemeral、EphemeralSequential
PERSISTENT 创建持久化节点,对应机器关闭连接后节点/数据不会消失
PERSISTENT_SEQUENTIAL 如果PATH是以’/’结尾则以这个PATH作为父节点,创建一个子节点,其子节点名字是一个按先后顺序排列的数值;否则创建一个名字是‘/’后面字符加上先后顺序排列的数值字符串的节点,同样创建持久节点
EPHEMERAL 创建瞬时节点,Zookeeper在感知连接机器宕机后会清除它创建的瞬时节点
EPHEMERAL_SEQUENTIAL 穿件瞬时顺序节点,和PERSISTENT_SEQUENTIAL一样,区别在于它是瞬时的
删除节点 delete
demo :zk.Delete(Dir, -1);
前一个参数代表节点名称(一般用作路径),后一个是版本号 -1表示全匹配
查看节点 exists
demo : zk.Exists(Dir, new MyWatch2());
获取数据 getData
demo :zk.GetData(Dir, new MyWatch2(), stat);
获取一个节点的数据,可注入watcher
设置数据 setData
demo : zk.SetData(Dir, new byte[1], 1);
获取下级节点集合 GetChildren
demo :zk.GetChildren(Dir, true);
存储
znodes类似文件和目录。但它不是一个典型的文件系统,zookeeper数据保存在内存中,这意味着zookeeper可以实现高吞吐量和低延迟。
watcher
Zookeeper有两种watches,一种是data watches,另一种是child watches。其中,getData()和exists()以及create()等会添加data watches,getChildren()会添加child watches。而delete()涉及到删除数据和子节点,会同时触发data watches和child watches。