`
liuzhiyi7288
  • 浏览: 31928 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

ZooKeeper实现分布式锁

 
阅读更多

 场景描述

 

         在分布式应用, 往往存在多个进程提供同一服务. 这些进程有可能在相同的机器上, 也有可能分布在不同的机器上. 如果这

 

些进程共享了一些资源, 可能就需要分布式锁来锁定对这些资源的访问.本文将介绍如何利用zookeeper实现分布式锁.

 

思路

 

       进程需要访问共享数据时, 就在"/locks"节点下创建一个sequence类型的子节点, 称为thisPath. 当thisPath在所有子节

 

点中最小时, 说明该进程获得了锁. 进程获得锁之后, 就可以访问共享资源了. 访问完成后, 需要将thisPath删除. 锁由新的最小的

 

子节点获得.

 

       有了清晰的思路之后, 还需要补充一些细节. 进程如何知道thisPath是所有子节点中最小的呢? 可以在创建的时候, 通过

 

getChildren方法获取子节点列表, 然后在列表中找到排名比thisPath前1位的节点, 称为waitPath, 然后在waitPath上注册监听,

 

当waitPath被删除后, 进程获得通知, 此时说明该进程获得了锁

 

实现
           以一个DistributedClient对象模拟一个进程的形式, 演示zookeeper分布式锁的实现.
          Java代码   收藏代码
  1. public class DistributedClient {  
  2.     // 超时时间  
  3.     private static final int SESSION_TIMEOUT = 5000;  
  4.     // zookeeper server列表  
  5.     private String hosts = "localhost:4180,localhost:4181,localhost:4182";  
  6.     private String groupNode = "locks";  
  7.     private String subNode = "sub";  
  8.   
  9.     private ZooKeeper zk;  
  10.     // 当前client创建的子节点  
  11.     private String thisPath;  
  12.     // 当前client等待的子节点  
  13.     private String waitPath;  
  14.   
  15.     private CountDownLatch latch = new CountDownLatch(1);  
  16.   
  17.     /** 
  18.      * 连接zookeeper 
  19.      */  
  20.     public void connectZookeeper() throws Exception {  
  21.         zk = new ZooKeeper(hosts, SESSION_TIMEOUT, new Watcher() {  
  22.             public void process(WatchedEvent event) {  
  23.                 try {  
  24.                     // 连接建立时, 打开latch, 唤醒wait在该latch上的线程  
  25.                     if (event.getState() == KeeperState.SyncConnected) {  
  26.                         latch.countDown();  
  27.                     }  
  28.   
  29.                     // 发生了waitPath的删除事件  
  30.                     if (event.getType() == EventType.NodeDeleted && event.getPath().equals(waitPath)) {  
  31.                         doSomething();  
  32.                     }  
  33.                 } catch (Exception e) {  
  34.                     e.printStackTrace();  
  35.                 }  
  36.             }  
  37.         });  
  38.   
  39.         // 等待连接建立  
  40.         latch.await();  
  41.   
  42.         // 创建子节点  
  43.         thisPath = zk.create("/" + groupNode + "/" + subNode, null, Ids.OPEN_ACL_UNSAFE,  
  44.                 CreateMode.EPHEMERAL_SEQUENTIAL);  
  45.   
  46.         // wait一小会, 让结果更清晰一些  
  47.         Thread.sleep(10);  
  48.   
  49.         // 注意, 没有必要监听"/locks"的子节点的变化情况  
  50.         List<String> childrenNodes = zk.getChildren("/" + groupNode, false);  
  51.   
  52.         // 列表中只有一个子节点, 那肯定就是thisPath, 说明client获得锁  
  53.         if (childrenNodes.size() == 1) {  
  54.             doSomething();  
  55.         } else {  
  56.             String thisNode = thisPath.substring(("/" + groupNode + "/").length());  
  57.             // 排序  
  58.             Collections.sort(childrenNodes);  
  59.             int index = childrenNodes.indexOf(thisNode);  
  60.             if (index == -1) {  
  61.                 // never happened  
  62.             } else if (index == 0) {  
  63.                 // inddx == 0, 说明thisNode在列表中最小, 当前client获得锁  
  64.                 doSomething();  
  65.             } else {  
  66.                 // 获得排名比thisPath前1位的节点  
  67.                 this.waitPath = "/" + groupNode + "/" + childrenNodes.get(index - 1);  
  68.                 // 在waitPath上注册监听器, 当waitPath被删除时, zookeeper会回调监听器的process方法  
  69.                 zk.getData(waitPath, true, new Stat());  
  70.             }  
  71.         }  
  72.     }  
  73.   
  74.     private void doSomething() throws Exception {  
  75.         try {  
  76.             System.out.println("gain lock: " + thisPath);  
  77.             Thread.sleep(2000);  
  78.             // do something  
  79.         } finally {  
  80.             System.out.println("finished: " + thisPath);  
  81.             // 将thisPath删除, 监听thisPath的client将获得通知  
  82.             // 相当于释放锁  
  83.             zk.delete(this.thisPath, -1);  
  84.         }  
  85.     }  
  86.   
  87.     public static void main(String[] args) throws Exception {  
  88.         for (int i = 0; i < 10; i++) {  
  89.             new Thread() {  
  90.                 public void run() {  
  91.                     try {  
  92.                         DistributedClient dl = new DistributedClient();  
  93.                         dl.connectZookeeper();  
  94.                     } catch (Exception e) {  
  95.                         e.printStackTrace();  
  96.                     }  
  97.                 }  
  98.             }.start();  
  99.         }  
  100.   
  101.         Thread.sleep(Long.MAX_VALUE);  
  102.     }  
  103. }   

思考

 

        思维缜密的朋友可能会想到, 上述的方案并不安全. 假设某个client在获得锁之前挂掉了, 由于client创建的节点是

 

ephemeral类型的, 因此这个节点也会被删除, 从而导致排在这个client之后的client提前获得了锁. 此时会存在多个client同时访

 

问共享资源.如何解决这个问题呢? 可以在接到waitPath的删除通知的时候, 进行一次确认, 确认当前的thisPath是否真的是列表

 

中最小的节点.

 

Java代码   收藏代码
  1. // 发生了waitPath的删除事件  
  2. if (event.getType() == EventType.NodeDeleted && event.getPath().equals(waitPath)) {  
  3.     // 确认thisPath是否真的是列表中的最小节点  
  4.     List<String> childrenNodes = zk.getChildren("/" + groupNode, false);  
  5.     String thisNode = thisPath.substring(("/" + groupNode + "/").length());  
  6.     // 排序  
  7.     Collections.sort(childrenNodes);  
  8.     int index = childrenNodes.indexOf(thisNode);  
  9.     if (index == 0) {  
  10.         // 确实是最小节点  
  11.         doSomething();  
  12.     } else {  
  13.         // 说明waitPath是由于出现异常而挂掉的  
  14.         // 更新waitPath  
  15.         waitPath = "/" + groupNode + "/" + childrenNodes.get(index - 1);  
  16.         // 重新注册监听, 并判断此时waitPath是否已删除  
  17.         if (zk.exists(waitPath, true) == null) {  
  18.             doSomething();  
  19.         }  
  20.     }  
  21. }  

另外, 由于thisPath和waitPath这2个成员变量会在多个线程中访问, 最好将他们声明为volatile, 以防止出现线程可见性问题.

 

另一种思路

    

         下面介绍一种更简单, 但是不怎么推荐的解决方案.
         

          每个client在getChildren的时候, 注册监听子节点的变化. 当子节点的变化通知到来时, 再一次通过getChildren获取子节

 

点列表, 判断thisPath是否是列表中的最小节点, 如果是, 则执行资源访问逻辑.

 
Java代码   收藏代码
  1. public class DistributedClient2 {  
  2.     // 超时时间  
  3.     private static final int SESSION_TIMEOUT = 5000;  
  4.     // zookeeper server列表  
  5.     private String hosts = "localhost:4180,localhost:4181,localhost:4182";  
  6.     private String groupNode = "locks";  
  7.     private String subNode = "sub";  
  8.   
  9.     private ZooKeeper zk;  
  10.     // 当前client创建的子节点  
  11.     private volatile String thisPath;  
  12.   
  13.     private CountDownLatch latch = new CountDownLatch(1);  
  14.   
  15.     /** 
  16.      * 连接zookeeper 
  17.      */  
  18.     public void connectZookeeper() throws Exception {  
  19.         zk = new ZooKeeper(hosts, SESSION_TIMEOUT, new Watcher() {  
  20.             public void process(WatchedEvent event) {  
  21.                 try {  
  22.                     // 连接建立时, 打开latch, 唤醒wait在该latch上的线程  
  23.                     if (event.getState() == KeeperState.SyncConnected) {  
  24.                         latch.countDown();  
  25.                     }  
  26.   
  27.                     // 子节点发生变化  
  28.                     if (event.getType() == EventType.NodeChildrenChanged && event.getPath().equals("/" + groupNode)) {  
  29.                         // thisPath是否是列表中的最小节点  
  30.                         List<String> childrenNodes = zk.getChildren("/" + groupNode, true);  
  31.                         String thisNode = thisPath.substring(("/" + groupNode + "/").length());  
  32.                         // 排序  
  33.                         Collections.sort(childrenNodes);  
  34.                         if (childrenNodes.indexOf(thisNode) == 0) {  
  35.                             doSomething();  
  36.                         }  
  37.                     }  
  38.                 } catch (Exception e) {  
  39.                     e.printStackTrace();  
  40.                 }  
  41.             }  
  42.         });  
  43.   
  44.         // 等待连接建立  
  45.         latch.await();  
  46.   
  47.         // 创建子节点  
  48.         thisPath = zk.create("/" + groupNode + "/" + subNode, null, Ids.OPEN_ACL_UNSAFE,  
  49.                 CreateMode.EPHEMERAL_SEQUENTIAL);  
  50.   
  51.         // wait一小会, 让结果更清晰一些  
  52.         Thread.sleep(10);  
  53.   
  54.         // 监听子节点的变化  
  55.         List<String> childrenNodes = zk.getChildren("/" + groupNode, true);  
  56.   
  57.         // 列表中只有一个子节点, 那肯定就是thisPath, 说明client获得锁  
  58.         if (childrenNodes.size() == 1) {  
  59.             doSomething();  
  60.         }  
  61.     }  
  62.   
  63.     /** 
  64.      * 共享资源的访问逻辑写在这个方法中 
  65.      */  
  66.     private void doSomething() throws Exception {  
  67.         try {  
  68.             System.out.println("gain lock: " + thisPath);  
  69.             Thread.sleep(2000);  
  70.             // do something  
  71.         } finally {  
  72.             System.out.println("finished: " + thisPath);  
  73.             // 将thisPath删除, 监听thisPath的client将获得通知  
  74.             // 相当于释放锁  
  75.             zk.delete(this.thisPath, -1);  
  76.         }  
  77.     }  
  78.   
  79.     public static void main(String[] args) throws Exception {  
  80.         for (int i = 0; i < 10; i++) {  
  81.             new Thread() {  
  82.                 public void run() {  
  83.                     try {  
  84.                         DistributedClient2 dl = new DistributedClient2();  
  85.                         dl.connectZookeeper();  
  86.                     } catch (Exception e) {  
  87.                         e.printStackTrace();  
  88.                     }  
  89.                 }  
  90.             }.start();  
  91.         }  
  92.   
  93.         Thread.sleep(Long.MAX_VALUE);  
  94.     }  
  95. }  

为什么不推荐这个方案呢? 是因为每次子节点的增加和删除都要广播给所有client, client数量不多时还看不出问题. 如果存在很

 

多client, 那么就可能导致广播风暴--过多的广播通知阻塞了网络. 使用第一个方案, 会使得通知的数量大大下降. 当然第一个方

 

案更复杂一些, 复杂的方案同时也意味着更容易引进bug.

 

 

转自：http://coolxing.iteye.com/blog/1871630

 

分享到：
| Innodb中的事务隔离级别和锁的关系
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    使用ZooKeeper实现分布式锁

    同时，`distribute-lock`这个文件可能包含了具体的实现代码或示例，通过学习和理解这个文件，我们可以更深入地掌握如何在实践中运用ZooKeeper实现分布式锁。 总之，ZooKeeper的分布式锁机制为解决分布式环境下的...

    基于zookeeper的分布式锁简单实现

    - **测试代码**：展示了如何在实际应用中使用Zookeeper实现分布式锁的示例，包括创建锁、获取锁、释放锁以及异常处理等操作。 - **实用工具类**：封装了与Zookeeper交互的常用方法，如创建节点、设置监听、检查节点...

    通过zookeeper实现分布式锁

    【Zookeeper实现分布式锁】 Zookeeper 是 Apache Hadoop 项目下的一个子项目，是一个高性能的分布式协调服务。它提供了一种可靠的方式来管理分布式系统中的配置信息、命名服务、集群管理和同步服务。Zookeeper 的...

    吊打面试官之基于zookeeper实现分布式锁源码

    本主题将深入探讨如何利用ZooKeeper实现分布式锁，并结合SpringCloud生态进行应用。ZooKeeper是一个分布式协调服务，而分布式锁是它的一个重要应用场景。 **ZooKeeper的特性与角色** 1. **强一致性**：ZooKeeper...

    zookeeper实现分布式锁

    在程序开发过程中不得不考虑的就是并发问题。在java中对于同一个jvm而言，jdk已经提供了lock和同步等。但是在分布式情况下，往往存在多个进程对一些资源产生竞争...分布式锁顾明思议就是可以满足分布式情况下的并发锁。

    基于zookeeper的分布式锁实现demo

    本部分将详细介绍使用Zookeeper实现分布式锁的知识点。 Zookeeper是Apache的一个开源项目，它为分布式应用提供了高可用性、顺序保证以及集群间同步等特性，它能够很好地帮助实现分布式锁。 **Zookeeper分布式锁的...

    基于zookeeper实现分布式锁

    zooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是集群的管理者。提供了文件系统和通知机制。...在开发项目的过程中，很多大型项目都是分布式部署的，那么我们现在使用zookeeper实现一个分布式锁。

    基于Zookeeper实现分布式锁实践教程

    本实践教程将指导你如何利用Zookeeper实现分布式锁，以便在分布式环境中保证资源访问的互斥性。 **1. Zookeeper概述** Zookeeper是一个分布式协调服务，它为分布式应用提供了简单而强大的命名服务、配置管理、集群...

    Zookeeper实现分布式锁

    在这个场景下，我们将详细探讨如何利用Zookeeper来实现分布式锁。 分布式锁的核心目标是在多个节点间实现互斥访问某个资源，确保同一时刻只有一个客户端能够持有锁。Zookeeper通过其提供的原子操作，如创建、删除...

    redis和zookeeper实现分布式锁的区别

    Redis和Zookeeper是两种常用的分布式协调服务，它们都可以用来实现分布式锁，但具体实现方式和特性有所不同。 **Redis分布式锁** Redis作为内存数据库，具有高性能、低延迟的特点，常被用作实现分布式锁。Redis...

    使用zookeeper实现分布式共享锁

    它被广泛用于实现分布式锁、配置管理、服务发现等多个场景。本篇文章将深入探讨如何使用Zookeeper实现分布式共享锁。 分布式锁是一种在多节点之间共享资源的机制，它允许在同一时间只有一个节点对资源进行操作。在...

    zookeeper做分布式锁

    分布式锁是解决多节点系统中同步问题的一种常见技术，ZooKeeper，由Apache基金会开发的分布式协调服务，常被用于实现高效可靠的分布式锁。本文将深入探讨如何利用ZooKeeper来构建分布式锁，并讨论其背后的关键概念和...

    如何操作Redis和zookeeper实现分布式锁

    如何操作Redis和zookeeper实现分布式锁 在分布式场景下，有很多种情况都需要实现最终一致性。在设计远程上下文的领域事件的时候，为了保证最终一致性，在通过领域事件进行通讯的方式中，可以共享存储（领域模型和...

    ZooKeeper 实现分布式锁的方法示例

    ZooKeeper 实现分布式锁的方法示例 ZooKeeper 是一个典型的分布式数据一致性解决方案，分布式应用程序可以基于 ZooKeeper 实现诸如数据发布/订阅、负载均衡、分布式协调/通知、集群管理、Master 选举、分布式锁等...

    C#基于zookeeper分布式锁的实现源码

    本篇将深入探讨如何在C#中利用ZooKeeper实现分布式锁。 首先，我们需要理解ZooKeeper的基本操作，包括创建节点（create）、读取节点（get）、更新节点（set）和删除节点（delete）。在分布式锁的场景中，通常会创建...

    Zookeeper 分布式重入排它锁实现

    **二、SpringBoot集成Zookeeper实现分布式锁** 1. **引入依赖**：在SpringBoot项目中，首先需要添加Zookeeper的相关依赖，如`spring-cloud-starter-zookeeper`。 2. **配置Zookeeper连接**：在`application....

    从Paxos到Zookeeper分布式一致性原理与实践 + ZooKeeper-分布式过程协同技术详解 pdf

    同时，ZooKeeper也是分布式锁的常见实现方式，通过创建临时节点实现锁的获取与释放。 总的来说，从Paxos到Zookeeper，我们看到的是分布式一致性理论与实践的逐步发展和完善。Paxos提供了一种理论基础，而ZooKeeper...

    ZooKeeper-分布式过程协同技术详解 和从Paxos到Zookeeper

    分布式锁是实现并发控制的关键，ZooKeeper提供了可重入的读写锁，确保并发操作的正确性。 此外，书中还会涉及ZooKeeper的安装、配置和监控，以及常见问题的排查和优化。对于开发者来说，理解ZooKeeper的API和最佳...

    zookeeper分布式锁

    为了更好地利用Zookeeper实现分布式锁，开发者需要理解Zookeeper的数据模型、API以及其提供的原子操作，如`create`、`exists`、`getChildren`和`delete`等。 综上所述，Zookeeper作为分布式锁的实现工具，凭借其...

Magicbox
Global site tag (gtag.js) - Google Analytics