(转)使用ZooKeeper实现的两个实例

标签： zookeeper 实例 | 发表时间：2014-06-12 16:28 | 作者：巴尾的兔兔帅
出处：http://www.iteye.com

        我们来看看，利用ZK实现分布式锁和实现实时更新server列表的功能的例子，转自：

                     http://coolxing.iteye.com/blog/1871630

                     http://coolxing.iteye.com/blog/1871520

**************************************以下为转载********************************

分布式锁：

场景描述

     在分布式应用, 往往存在多个进程提供同一服务. 这些进程有可能在相同的机器上, 也有可能分布在不同的机器上. 如果这些进程共享了一些资源, 可能就需要分布式锁来锁定对这些资源的访问.
本文将介绍如何利用zookeeper实现分布式锁.

思路

    进程需要访问共享数据时, 就在"/locks"节点下创建一个sequence类型的子节点, 称为thisPath. 当thisPath在所有子节点中最小时, 说明该进程获得了锁. 进程获得锁之后, 就可以访问共享资源了. 访问完成后, 需要将thisPath删除. 锁由新的最小的子节点获得.
有了清晰的思路之后, 还需要补充一些细节. 进程如何知道thisPath是所有子节点中最小的呢? 可以在创建的时候, 通过getChildren方法获取子节点列表, 然后在列表中找到排名比thisPath前1位的节点, 称为waitPath, 然后在waitPath上注册监听, 当waitPath被删除后, 进程获得通知, 此时说明该进程获得了锁.

实现

以一个DistributedClient对象模拟一个进程的形式, 演示zookeeper分布式锁的实现.

 
  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同时访问共享资源.

对上面的解释：

    现在有subs5 sub6  subs7  subs8几个子节点，当前subs5正获得锁，如果subs6对应的client6挂掉，则subs6被删除--出发了client7那边的监听，导致client7也拿到了锁，导致5和7的客户端同时得到锁。
   如何解决这个问题呢? 可以在接到waitPath的删除通知的时候, 进行一次确认, 确认当前的thisPath是否真的是列表中最小的节点.

 
  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是否是列表中的最小节点, 如果是, 则执行资源访问逻辑.

 
  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.

 

***************************************************************************************************

 

实时更新server列表：

    通过之前的3篇博文, 讲述了ZooKeeper的基础知识点. 可以看出, ZooKeeper提供的核心功能是非常简单, 且易于学习的. 可能会给人留下ZooKeeper并不强大的印象, 事实并非如此, 基于ZooKeeper的核心功能, 我们可以扩展出很多非常有意思的应用. 接下来的几篇博文, 将陆续介绍ZooKeeper的典型应用场景.

场景描述

    在分布式应用中, 我们经常同时启动多个server, 调用方(client)选择其中之一发起请求.
    分布式应用必须考虑高可用性和可扩展性: server的应用进程可能会崩溃, 或者server本身也可能会宕机. 当server不够时, 也有可能增加server的数量. 总而言之, server列表并非一成不变, 而是一直处于动态的增减中.
    那么client如何才能实时的更新server列表呢? 解决的方案很多, 本文将讲述利用ZooKeeper的解决方案.

思路

    启动server时, 在zookeeper的某个znode(假设为/sgroup)下创建一个子节点. 所创建的子节点的类型应该为ephemeral, 这样一来, 如果server进程崩溃, 或者server宕机, 与zookeeper连接的session就结束了, 那么其所创建的子节点会被zookeeper自动删除. 当崩溃的server恢复后, 或者新增server时, 同样需要在/sgroup节点下创建新的子节点.
    对于client, 只需注册/sgroup子节点的监听, 当/sgroup下的子节点增加或减少时, zookeeper会通知client, 此时client更新server列表.

实现AppServer

    AppServer的逻辑非常简单, 只须在启动时, 在zookeeper的"/sgroup"节点下新增一个子节点即可.

 
  1. public class AppServer {  
  2.     private String groupNode = "sgroup";  
  3.     private String subNode = "sub";  
  4.   
  5.     /** 
  6.      * 连接zookeeper 
  7.      * @param address server的地址 
  8.      */  
  9.     public void connectZookeeper(String address) throws Exception {  
  10.         ZooKeeper zk = new ZooKeeper("localhost:4180,localhost:4181,localhost:4182", 5000, new Watcher() {  
  11.             public void process(WatchedEvent event) {  
  12.                 // 不做处理  
  13.             }  
  14.         });  
  15.         // 在"/sgroup"下创建子节点  
  16.         // 子节点的类型设置为EPHEMERAL_SEQUENTIAL, 表明这是一个临时节点, 且在子节点的名称后面加上一串数字后缀  
  17.         // 将server的地址数据关联到新创建的子节点上  
  18.         String createdPath = zk.create("/" + groupNode + "/" + subNode, address.getBytes("utf-8"),   
  19.             Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);  
  20.         System.out.println("create: " + createdPath);  
  21.     }  
  22.       
  23.     /** 
  24.      * server的工作逻辑写在这个方法中 
  25.      * 此处不做任何处理, 只让server sleep 
  26.      */  
  27.     public void handle() throws InterruptedException {  
  28.         Thread.sleep(Long.MAX_VALUE);  
  29.     }  
  30.       
  31.     public static void main(String[] args) throws Exception {  
  32.         // 在参数中指定server的地址  
  33.         if (args.length == 0) {  
  34.             System.err.println("The first argument must be server address");  
  35.             System.exit(1);  
  36.         }  
  37.           
  38.         AppServer as = new AppServer();  
  39.         as.connectZookeeper(args[0]);  
  40.           
  41.         as.handle();  
  42.     }  
  43. }  

将其打成appserver.jar后待用, 生成jar时别忘了指定入口函数. 具体的教程请自行搜索.

 

实现AppClient

    AppClient的逻辑比AppServer稍微复杂一些, 需要监听"/sgroup"下子节点的变化事件, 当事件发生时, 需要更新server列表.
    注册监听"/sgroup"下子节点的变化事件, 可在getChildren方法中完成. 当zookeeper回调监听器的process方法时, 判断该事件是否是"/sgroup"下子节点的变化事件, 如果是, 则调用更新逻辑, 并再次注册该事件的监听.

 
  1. public class AppClient {  
  2.     private String groupNode = "sgroup";  
  3.     private ZooKeeper zk;  
  4.     private Stat stat = new Stat();  
  5.     private volatile List<String> serverList;  
  6.   
  7.     /** 
  8.      * 连接zookeeper 
  9.      */  
  10.     public void connectZookeeper() throws Exception {  
  11.         zk = new ZooKeeper("localhost:4180,localhost:4181,localhost:4182", 5000, new Watcher() {  
  12.             public void process(WatchedEvent event) {  
  13.                 // 如果发生了"/sgroup"节点下的子节点变化事件, 更新server列表, 并重新注册监听  
  14.                 if (event.getType() == EventType.NodeChildrenChanged   
  15.                     && ("/" + groupNode).equals(event.getPath())) {  
  16.                     try {  
  17.                         updateServerList();  
  18.                     } catch (Exception e) {  
  19.                         e.printStackTrace();  
  20.                     }  
  21.                 }  
  22.             }  
  23.         });  
  24.   
  25.         updateServerList();  
  26.     }  
  27.   
  28.     /** 
  29.      * 更新server列表 
  30.      */  
  31.     private void updateServerList() throws Exception {  
  32.         List<String> newServerList = new ArrayList<String>();  
  33.   
  34.         // 获取并监听groupNode的子节点变化  
  35.         // watch参数为true, 表示监听子节点变化事件.   
  36.         // 每次都需要重新注册监听, 因为一次注册, 只能监听一次事件, 如果还想继续保持监听, 必须重新注册  
  37.         List<String> subList = zk.getChildren("/" + groupNode, true);  
  38.         for (String subNode : subList) {  
  39.             // 获取每个子节点下关联的server地址  
  40.             byte[] data = zk.getData("/" + groupNode + "/" + subNode, false, stat);  
  41.             newServerList.add(new String(data, "utf-8"));  
  42.         }  
  43.   
  44.         // 替换server列表  
  45.         serverList = newServerList;  
  46.   
  47.         System.out.println("server list updated: " + serverList);  
  48.     }  
  49.   
  50.     /** 
  51.      * client的工作逻辑写在这个方法中 
  52.      * 此处不做任何处理, 只让client sleep 
  53.      */  
  54.     public void handle() throws InterruptedException {  
  55.         Thread.sleep(Long.MAX_VALUE);  
  56.     }  
  57.   
  58.     public static void main(String[] args) throws Exception {  
  59.         AppClient ac = new AppClient();  
  60.         ac.connectZookeeper();  
  61.   
  62.         ac.handle();  
  63.     }  
  64. }  

将其打包成appclient.jar后待用, 别忘了指定入口函数.

 

运行

    在运行jar包之前, 需要确认zookeeper中是否已经存在"/sgroup"节点了, 没有不存在, 则创建该节点. 如果存在, 最好先将其删除, 然后再重新创建. ZooKeeper的相关命令可参考我的另一篇博文.
运行appclient.jar:  java -jar appclient.jar 开启多个命令行窗口, 每个窗口运行appserver.jar进程: java -jar appserver.jar server0000. "server0000"表示server的地址, 别忘了给每个server设定一个不同的地址. 观察appclient的输出.
依次结束appserver的进程, 观察appclient的输出.
appclient的输出类似于:

 
  1. server list updated: []  
  2. server list updated: [server0000]  
  3. server list updated: [server0000, server0001]  
  4. server list updated: [server0000, server0001, server0002]  
  5. server list updated: [server0000, server0001, server0002, server0003]  
  6. server list updated: [server0000, server0001, server0002]  
  7. server list updated: [server0000, server0001]  
  8. server list updated: [server0000]  
  9. server list updated: []  


已有 0 人发表留言，猛击->> 这里<<-参与讨论


ITeye推荐



相关 [zookeeper 实例] 推荐：

(转)使用ZooKeeper实现的两个实例

- - 企业架构 - ITeye博客
        我们来看看，利用ZK实现分布式锁和实现实时更新server列表的功能的例子，转自：. **************************************以下为转载********************************.      在分布式应用, 往往存在多个进程提供同一服务.

zookeeper( 转)

- - 企业架构 - ITeye博客
转自：http://qindongliang.iteye.com/category/299318. 分布式助手Zookeeper（一）. Zookeeper最早是Hadoop的一个子项目，主要为Hadoop生态系统中一些列组件提供统一的分布式协作服务，在2010年10月升级成Apache Software .

ZooKeeper监控

- - 淘宝网通用产品团队博客
        在公司内部，有不少应用已经强依赖zookeeper，比如meta和精卫系统，zookeeper的工作状态直接影响它们的正常工作. 目前开源世界中暂没有一个比较成熟的zk-monitor,公司内部的各个zookeeper运行也都是无监控，无报表状态. 目前zookeeper-monitor能做哪些事情，讲到这个，首先来看看哪些因素对zookeeper正常工作比较大的影响：.

zookeeper原理

- - CSDN博客云计算推荐文章
1.为了解决分布式事务性一致的问题. 2.文件系统也是一个树形的文件系统，但比linux系统简单，不区分文件和文件夹，所有的文件统一称为znode. 3.znode的作用：存放数据，但上限是1M ;存放ACL(access control list)访问控制列表，每个znode被创建的时候，都会带有一个ACL，身份验证方式有三种：digest(用户名密码验证)，host(主机名验证)，ip(ip验证) ，ACL到底有哪些权限呢.

Zookeeper Client简介

- - zzm
直接使用zk的api实现业务功能比较繁琐. 因为要处理session loss，session expire等异常，在发生这些异常后进行重连. 又因为ZK的watcher是一次性的，如果要基于wather实现发布/订阅模式，还要自己包装一下，将一次性订阅包装成持久订阅. 另外如果要使用抽象级别更高的功能，比如分布式锁，leader选举等，还要自己额外做很多事情.

zookeeper 理论

- - zzm
引用官方的说法：“Zookeeper是一个高性能，分布式的，开源分布式应用协调服务. 它提供了简单原始的功能，分布式应用可以基于它实现更高级 的服务，比如同步，配置管理，集群管理，名空间. 它被设计为易于编程，使用文件系统目录树作为数据模型. 服务端跑在java上，提供java和C的客户端 API”.

ZooKeeper 入门

- - 企业架构 - ITeye博客
ZooKeeper是一个高可用的分布式数据管理与系统协调框架. 基于对Paxos算法的实现，使该框架保证了分布式环境中数据的强一致性，也正是基于这样的特性，使得ZooKeeper解决很多分布式问题. 网上对ZK的应用场景也有不少介绍，本文将结合作者身边的项目例子，系统地对ZK的应用场景进行一个分门归类的介绍.

zookeeper场景

- - 企业架构 - ITeye博客
发布与订阅模型，即所谓的配置中心，顾名思义就是发布者将数据发布到ZK节点上，供订阅者动态获取数据，实现配置信息的集中式管理和动态更新. 例如全局的配置信息，服务式服务框架的服务地址列表等就非常适合使用. 应用中用到的一些配置信息放到ZK上进行集中管理. 这类场景通常是这样：应用在启动的时候会主动来获取一次配置，同时，在节点上注册一个Watcher，这样一来，以后每次配置有更新的时候，都会实时通知到订阅的客户端，从来达到获取最新配置信息的目的.

Zookeeper的Session

- - 行业应用 - ITeye博客
介绍一下基于zookeeper的一些API的编程. 在此之前，我们先来熟悉一下相关知识：. Zookeeper的Session：. （1）客户端和server间采用长连接. （2）连接建立后，server产生session ID（64位）返还给客户端. （3）客户端定期发送ping包来检查和保持和server的连接.

Paxos与zookeeper

- - 互联网 - ITeye博客
1，什么是Paxos算法. Paxos算法是分布式计算领域中一个非常重要的算法，主要解决分布式系统如何就某个值（决议）达成一致的问题. 一个典型的场景是分布式数据库的一致问题：如果分布式数据库的各个节点初始状态一致，又能执行相同的操作序列，那么最后能达到一个一致的状态. 但是如何保证在每个节点上执行相同的命令序列呢.