1. 快速开始

1.1概述:

Zookeeper是Hadoop的一个子项目,它是分布式系统中的协调系统,可提供的服务主要有:配置服务、名字服务、分布式同步、组服务等。
1.2 使用常见

1.2.1 统一配置

把配置放在ZooKeeper的节点中维护,当配置变更时,客户端可以收到变更的通知,并应用最新的配置。

1.2.2,集群管理

集群中的节点,创建ephemeral的节点,一旦断开连接,ephemeral的节点会消失,其它的集群机器可以收到消息。

1.2.3 分布式锁

多个客户端发起节点创建操作,只有一个客户端创建成功,从而获得锁。

1.3 安装和配置

通过官方下载链接zookeeper 进行下载,解压后进入conf目录,新建一个zoo.conf文件,配置内容如下:

  1. tickTime=2000
  2. dataDir=/Users/lsq/Documents/zookeeper/zookeeper0/data
  3. dataLogDir=/Users/lsq/Documents/zookeeper/zookeeper0/dataLog
  4. clientPort=4399
  5. initLimit=5
  6. syncLimit=2

tickTime: ZooKeeper基本时间单位(ms)
initLimit: 指定了启动zookeeper时,zookeeper实例中的随从实例同步到领导实例的初始化连接时间限制,超出时间限制则连接失败(以tickTime为时间单位);
syncLimit: 指定了zookeeper正常运行时,主从节点之间同步数据的时间限制,若超过这个时间限制,那么随从实例将会被丢弃
dataDir: zookeeper存放数据的目录;
clientPort: 用于连接客户端的端口

接下来进入bin目录启动ZooKeeper实例以及客户端连接:

  1. ./zkServer.sh start
  2. ./zkCli.sh -server localhost:4399

接下来看看集群如何配置,其实跟单机差不多,这里我们把刚刚下载的Zookeeper复制多两份,一共是三个,配置信息如下:

  1. tickTime=2000
  2. dataDir=/Users/lsq/Documents/zookeeper/zookeeper0/data
  3. dataDir=/Users/lsq/Documents/zookeeper/zookeeper0/dataLog
  4. clientPort=4399
  5. initLimit=5
  6. syncLimit=2
  7. server.1=127.0.0.1:8880:9990
  8. server.2=127.0.0.1:8881:9991
  9. server.3=127.0.0.1:8882:9992

三个文件夹下面的zoo.conf都是这个格式,需要修改dataDir,dataDir,clientPort,
然后在dataDir所指向的目录下面新建一个myid文件,对应server.x,比如第一个文件夹下面的myid就填入一个1,第二个就填入一个2,以此类推。接着依次启动即可。可以采用下面的命令

  1. echo "" > myid

2.使用java来操作ZooKeeper实例
一门技术最重要的就算实战了,接下来的内容将围绕这一部分来讲。
首先是Znode的创建和删除
Znode有两种类型:短暂的和持久的。短暂的znode在创建的客户端与服务器端断开(无论是明确的断开还是故障断开)连接时,该znode都会被删除;相反,持久的znode则不会

  1. public class CreateGroup implements Watcher {
  2. //会话延时
  3. private static final int SESSION_TIMEOUT = 1000;
  4. //zk对象
  5. private ZooKeeper zk = null;
  6. //同步计数器
  7. private CountDownLatch countDownLatch = new CountDownLatch(1);
  8. //客户端连接到服务器时会触发观察者进行调用
  9. public void process(WatchedEvent event) {
  10. if(event.getState() == KeeperState.SyncConnected){
  11. countDownLatch.countDown();//计数器减一
  12. }
  13. }
  14.  
  15. public void connect(String hosts) throws IOException, InterruptedException {
  16. zk = new ZooKeeper(hosts, SESSION_TIMEOUT, this);
  17. countDownLatch.await();//阻塞程序继续执行
  18. }
  19. //创建GROUP
  20. public void create(String groupName) throws KeeperException, InterruptedException{
  21. String path = "/" + groupName;
  22. //允许任何客户端对该znode进行读写,以及znode进行持久化
  23. String createPath = zk.create(path, null, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
  24. System.out.println("Created "+createPath);
  25. }
  26. //关闭zk
  27. public void close() throws InterruptedException{
  28. if(zk != null){
  29. try {
  30. zk.close();
  31. } catch (InterruptedException e) {
  32. throw e;
  33. }finally{
  34. zk = null;
  35. System.gc();
  36. }
  37. }
  38. }
  39.  
  40. //测试主类
  41. public static void main(String args[]){
  42. String host = "127.0.0.1:4399";
  43. String groupName = "test";
  44. CreateGroup createGroup = new CreateGroup();
  45. try {
  46. createGroup.connect(host);
  47. createGroup.create(groupName);
  48. createGroup.close();
  49. createGroup = null;
  50. System.gc();
  51. } catch (IOException e) {
  52. e.printStackTrace();
  53. } catch (InterruptedException e) {
  54. e.printStackTrace();
  55. } catch (KeeperException e) {
  56. e.printStackTrace();
  57. }
  58. }
  59. }

接下来把创建和销毁分离出来作为一个独立的类,以后相关操作可以直接使用

  1. public class ConnetctionWatcher implements Watcher {
  2.  
  3. private static final int SESSION_TIMEOUT = 5000;
  4.  
  5. protected ZooKeeper zk = null;
  6. private CountDownLatch countDownLatch = new CountDownLatch(1);
  7.  
  8. public void process(WatchedEvent event) {
  9. KeeperState state = event.getState();
  10.  
  11. if(state == KeeperState.SyncConnected){
  12. countDownLatch.countDown();
  13. }
  14. }
  15. public void connection(String hosts) throws IOException, InterruptedException {
  16. zk = new ZooKeeper(hosts, SESSION_TIMEOUT, this);
  17. countDownLatch.await();
  18. }
  19. public void close() throws InterruptedException {
  20. if (null != zk) {
  21. try {
  22. zk.close();
  23. } catch (InterruptedException e) {
  24. throw e;
  25. }finally{
  26. zk = null;
  27. System.gc();
  28. }
  29. }
  30. }
  31. }

接下来我们看看节点如何删除

  1. public class DeleteGroup extends ConnetctionWatcher {
  2. public void delete(String groupName) {
  3. String path = "/" + groupName;
  4.  
  5. try {
  6. List<String> children = zk.getChildren(path, false);
  7.  
  8. for(String child : children){
  9. zk.delete(path + "/" + child, -1);
  10. }
  11. zk.delete(path, -1);//版本号为-1,
  12. } catch (KeeperException e) {
  13. e.printStackTrace();
  14. } catch (InterruptedException e) {
  15. e.printStackTrace();
  16. }
  17. }
  18. }

3. 利用java实现分布式Barrier
Barrier是一种控制和协调多个任务触发次序的机制。简单来说就是用一个屏障把将要执行的任务拦住,等待所有任务都处于可运行状态才放开屏障,其实在单机上我们可以利用CyclicBarrier来实现这个机制,但是在分布式环境下,我们可以利用ZooKeeper可以派上用场,我们可以利用一个Node来作为Barrier的实体,然后要Barrier的任务通过调用exists检测是否Node存在,当需要打开Barrier时候,删除这个Node,这样ZooKeeper的watch机制会通知到各个任务可以开始执行。接下来看代码:

  1. public class Barrier extends SyncPrimitive {
  2. int size;
  3. String name;
  4.  
  5. Barrier(String address, String root, int size) {
  6. super(address);
  7. this.root = root;
  8. this.size = size;
  9. //创建Barrier的Node
  10. if (zk != null) {
  11. try {
  12. Stat s = zk.exists(root, false);
  13. if (s == null) {
  14. zk.create(root, new byte[0], Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
  15. }
  16. } catch (KeeperException e) {
  17. System.out.println("Keeper exception when instantiating queue: " + e.toString());
  18. } catch (InterruptedException e) {
  19. System.out.println("Interrupted exception");
  20. }
  21. }
  22. try {
  23. name = new String(InetAddress.getLocalHost().getCanonicalHostName().toString());
  24. } catch (UnknownHostException e) {
  25. System.out.println(e.toString());
  26. }
  27.  
  28. }
  29.  
  30. /**
  31. * 加入Barrier等待
  32. */
  33.  
  34. boolean enter() throws KeeperException, InterruptedException{
  35. zk.create(root + "/" + name, new byte[0], Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
  36. while (true) {
  37. synchronized (mutex) {
  38. List<String> list = zk.getChildren(root, true);
  39. if (list.size() < size) {
  40. mutex.wait();
  41. } else {
  42. return true;
  43. }
  44. }
  45. }
  46. }
  47.  
  48. /**
  49. * 一直等待知道指定数量节点到达
  50. */
  51.  
  52. boolean leave() throws KeeperException, InterruptedException{
  53. zk.delete(root + "/" + name, 0);
  54. while (true) {
  55. synchronized (mutex) {
  56. List<String> list = zk.getChildren(root, true);
  57. if (list.size() > 0) {
  58. mutex.wait();
  59. } else {
  60. return true;
  61. }
  62. }
  63. }
  64. }
  65. }

父类代码如下

  1. public class SyncPrimitive implements Watcher {
  2. static ZooKeeper zk = null;
  3. static Integer mutex;
  4. //根节点
  5. String root;
  6. SyncPrimitive(String address) {
  7. if(zk == null){
  8. try {
  9. System.out.println("Starting ZK:");
  10. zk = new ZooKeeper(address, 3000, this);
  11. mutex = new Integer(-1);
  12. System.out.println("Finished starting ZK: " + zk);
  13. } catch (IOException e) {
  14. System.out.println(e.toString());
  15. zk = null;
  16. }
  17. }
  18. //else mutex = new Integer(-1);
  19. }
  20.  
  21. synchronized public void process(WatchedEvent event) {
  22. synchronized (mutex) {
  23. System.out.println("Process: " + event.getType());
  24. mutex.notify();
  25. }
  26. }
  27.  
  28. public static void queueTest(String args[]) {
  29. Queue q = new Queue(args[1], "/app1");
  30.  
  31. System.out.println("Input: " + args[1]);
  32. int i;
  33. Integer max = new Integer(args[2]);
  34.  
  35. if (args[3].equals("p")) {
  36. System.out.println("Producer");
  37. for (i = 0; i < max; i++)
  38. try{
  39. q.produce(10 + i);
  40. } catch (KeeperException e){
  41.  
  42. } catch (InterruptedException e){
  43.  
  44. }
  45. } else {
  46. System.out.println("Consumer");
  47.  
  48. for (i = 0; i < max; i++) {
  49. try{
  50. int r = q.consume();
  51. System.out.println("Item: " + r);
  52. } catch (KeeperException e){
  53. i--;
  54. } catch (InterruptedException e){
  55.  
  56. }
  57. }
  58. }
  59. }
  60.  
  61. public static void barrierTest(String args[]) {
  62. Barrier b = new Barrier(args[1], "/b1", new Integer(args[2]));
  63. try{
  64. boolean flag = b.enter();
  65. System.out.println("Entered barrier: " + args[2]);
  66. if(!flag) System.out.println("Error when entering the barrier");
  67. } catch (KeeperException e){
  68.  
  69. } catch (InterruptedException e){
  70.  
  71. }
  72. Random rand = new Random();
  73. int r = rand.nextInt(100);
  74. for (int i = 0; i < r; i++) {
  75. try {
  76. Thread.sleep(100);
  77. } catch (InterruptedException e) {
  78.  
  79. }
  80. }
  81. try{
  82. b.leave();
  83. } catch (KeeperException e){
  84. } catch (InterruptedException e){
  85. }
  86. System.out.println("Left barrier");
  87. }
  88. //测试用的主类
  89. public static void main(String args[]) {
  90. /*
  91. args =new String[] {"qTest","localhost:4399","3","c"};
  92. if (args[0].equals("qTest"))
  93. queueTest(args);
  94. else
  95. barrierTest(args);
  96. */
  97. }
  98. }

4. 分布式队列(Queue)
在分布式环境下,实现Queue需要高一致性来保证,那么我们可以这样来设计。把一个Node当成一个队列,然后children用来存储内容,利用ZooKeeper提供的顺序递增的模式(会自动在name后面加入一个递增的数字来插入新元素)。于是在offer时候我们可以使用create,take时候按照顺序把children第一个delete就可以了。ZooKeeper保证了各个server上数据是一致的。废话不多说了,直接看代码

  1. /**
  2. * 一个消费者-生产者模式的消息队列
  3. */
  4. public class Queue extends SyncPrimitive {
  5.  
  6. Queue(String address, String name) {
  7. super(address);
  8. this.root = name;
  9. if (zk != null) {
  10. try {
  11. Stat s = zk.exists(root, false);
  12. if (s == null) {
  13. zk.create(root, new byte[0], Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
  14. }
  15. } catch (KeeperException e) {
  16. System.out.println("Keeper exception when instantiating queue: " + e.toString());
  17. } catch (InterruptedException e) {
  18. System.out.println("Interrupted exception");
  19. }
  20. }
  21. }
  22.  
  23. /**
  24. * 队列中插入数据
  25. */
  26.  
  27. boolean produce(int i) throws KeeperException, InterruptedException{
  28. ByteBuffer b = ByteBuffer.allocate(4);
  29. byte[] value;
  30.  
  31. b.putInt(i);
  32. value = b.array();
  33. zk.create(root + "/element", value, Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT_SEQUENTIAL);
  34.  
  35. return true;
  36. }
  37.  
  38. /**
  39. * 把元素从队列中移除
  40. */
  41. int consume() throws KeeperException, InterruptedException{
  42. int retvalue = -1;
  43. Stat stat = null;
  44.  
  45. //得到现在队列中首个可用的节点
  46. while (true) {
  47. synchronized (mutex) {
  48. List<String> list = zk.getChildren(root, true);
  49. if (list.size() == 0) {
  50. System.out.println("Going to wait");
  51. mutex.wait();
  52. } else {
  53. Integer min = new Integer(list.get(0).substring(7));
  54. for(String s : list){
  55. Integer tempValue = new Integer(s.substring(7));
  56. //System.out.println("Temporary value: " + tempValue);
  57. if(tempValue < min) min = tempValue;
  58. }
  59. System.out.println("Temporary value: " + root + "/element" + min);
  60. byte[] b = zk.getData(root + "/element" + min, false, stat);
  61. zk.delete(root + "/element" + min, 0);
  62. ByteBuffer buffer = ByteBuffer.wrap(b);
  63. retvalue = buffer.getInt();
  64.  
  65. return retvalue;
  66. }
  67. }
  68. }
  69. }
  70. }

ZooKeeper系列(9):ZooKeeper实现分布式Barrier和Queue的更多相关文章

  1. 【Zookeeper系列】ZooKeeper管理分布式环境中的数据(转)

    原文地址:https://www.cnblogs.com/sunddenly/p/4092654.html 引言 本节本来是要介绍ZooKeeper的实现原理,但是ZooKeeper的原理比较复杂,它 ...

  2. ZooKeeper系列(5):管理分布式环境中的数据

    引言 本节本来是要介绍ZooKeeper的实现原理,但是ZooKeeper的原理比较复杂,它涉及到了paxos算法.Zab协议.通信协议等相关知 识,理解起来比较抽象所以还需要借助一些应用场景,来帮我 ...

  3. zookeeper系列之六—zookeeper之应用

    http://www.cnblogs.com/sharpxiajun/archive/2013/06/02/3113923.html Zookeeper是hadoop的一个子项目,虽然源自hadoop ...

  4. 【Zookeeper系列】zookeeper面试题(转)

    原文链接:https://segmentfault.com/a/1190000014479433 1.ZooKeeper是什么? ZooKeeper是一个分布式的,开放源码的分布式应用程序协调服务,是 ...

  5. 【Zookeeper系列】ZooKeeper一致性原理(转)

    原文链接:https://www.cnblogs.com/sunddenly/p/4138580.html 一.ZooKeeper 的实现 1.1 ZooKeeper处理单点故障 我们知道可以通过Zo ...

  6. 【Zookeeper系列】Zookeeper命令操作(转)

    原文链接:https://www.cnblogs.com/sunddenly/p/4031881.html 一.Zookeeper的四字命令 Zookeeper支持某些特定的四字命令字母与其的交互.他 ...

  7. 【Zookeeper系列】ZooKeeper安装配置(转)

    原文链接:https://www.cnblogs.com/sunddenly/p/4018459.html 一.Zookeeper的搭建方式 Zookeeper安装方式有三种,单机模式和集群模式以及伪 ...

  8. 【Zookeeper系列】Zookeeper简单介绍(转)

    原文链接:https://www.cnblogs.com/sunddenly/p/4033574.html 一.分布式协调技术 在给大家介绍ZooKeeper之前先来给大家介绍一种技术——分布式协调技 ...

  9. 【Zookeeper系列】ZooKeeper机制架构(转)

    原文链接:https://www.cnblogs.com/sunddenly/p/4133784.html 一.ZooKeeper权限管理机制 1.1 权限管理ACL(Access Control L ...

随机推荐

  1. IE浏览器兼容问题

    文件兼容性用于定义让IE如何编译你的网页.此文件解释文件兼容性,如何指定你网站的文件兼容性模式以及如何判断一个网页该使用的文件模式. 为了帮助确保你的网页在所有未来的IE版本都有一致的外观,IE8引入 ...

  2. JDK8中的时间API

    在Java 1.0中,对日期和时间的支持只能依赖java.util.Date类.正如类名所表达的,这个类无法表示日期,只能以毫秒的精度表示时间.更糟糕的是它的易用性,由于某些原因未知的设计决策,这个类 ...

  3. idea 中maven编译速度过慢的问题的解决

    解决方案一 在创建Maven项目时加上 archetypeCatalog=internal 参数,如下: 解决方案二 在maven的VM Options加上-DarchetypeCatalog=int ...

  4. python string/list转换

    python的read.write方法的操作对象都是string.输入.输出和逻辑业务上很多时候都要用到string.list互转. 1.简单用法 import stringstr = 'abcde' ...

  5. TestNG.xml参数配置-如何控制部分执行@test方法

    如果在methods中标识了@test的方法,也可以在method中通过include和exclude来控制需要执行哪些方法 <include name="testMethod1&qu ...

  6. npm install 包 失败解决方法

    在ionic 安装包的时候 npm install xxx --save 出现如下错误 查看日志文件 14 verbose stack SyntaxError: Unexpected token &l ...

  7. Vivado约束文件(XDC)的探究(1)

    Vivado约束文件(XDC)的探究(1) 工程建好之后会出现xdc文件: 注意:active 和 target 生成的约束文件如下:

  8. 进程池pool

    如果有多个进程,同一时间只能有限个给cpu运行 from multiprocessing import Process,Pool import time,os def bar(arg): print( ...

  9. Debian下Netbeans编辑器字体锯齿现象

    第一步:到你netbeans安装目录下的etc目录下,找到netbeans.conf文件,打开准备编辑:第二步:在netbeans_default_options后面加上-J-Dawt.useSyst ...

  10. WCF类型共享技巧【转载】

    调用过WCF服务的同学可能都会遇到这样的问题,同一个实体类型,不同的服务Visual Studio生成了不同的版本,例如Service1.User和Service2.User,对于C#来说,这是两个不 ...