大数据必学框架-ZooKeeper

深碍√TFBOYSˉ_ 2023-10-04 16:39 24阅读 0赞

## 大数据框架-ZooKeeper ##

### 简介： ###

#### 概述： ####

**Zookeeper 是一个开源的分布式的，为分布式框架提供协调服务的 Apache 项目。**

Zookeeper从设计模式角度来理解：是一个基于观察者模式设计的分布式服务管理框架，它负责存储和管理大家都关心的数据，然后接受观察者的注册，一旦这些数据的状态发生变化，Zookeeper就将负责通知已经在Zookeeper上注册的那些观察者做出相应的反应

对于ZooKeeper来说，是监控Hadoop生态圈，为数据和系统的正常执行提高保障和监控，如果监控到哪个环节出现状况，可以做出相应措施。

#### 特点： ####

1.  在ZooKeeper中只有一个领导者（leader），但是可以有多个跟随者（Follower）
2.  集群中只要有半数以上的节点在正常运行，ZooKeeper集群就可以正常工作，**所以在进行ZooKeeper安装的时候，要安装为奇数台**
3.  在集群中的节点中，保存的数据都是一样的，每个server保存一份相同的数据副本，**client无论连接哪一个server，数据内容都是一样的**
4.  更新请求顺序执行，来自同一个Client的更新请求按其发送顺序依次执行。
5.  **数据更新原子性，一次数据更新要么成功，要么失败。**
6.  实时性，**在一定时间范围内**，Client能读到最新数据。

#### 数据结构 ####

ZooKeeper 数据模型的结构与 Unix 文件系统很类似，整体上可以看作是一棵树，每个  
节点称做一个 ZNode。每一个 ZNode 默认能够存储 1MB 的数据，每个 ZNode 都可以通过  
其路径唯一标识

#### 应用场景 ####

提供的服务包括：统一命名服务、统一配置管理、统一集群管理、服务器节点动态上下线、软负载均衡等。

比如对于一个IP地址，是很难记住的，而域名就可以很方便的记住，比如baidu.com等，而在分布式环境下，经常需要对应用/服务进行统一命名，便于识别

再者，在我们的集群中会有很多配置文件，如果每个机器都去更改一遍配置文件就会增加很大的任务量，那么就可以将配置管理交给ZooKeeper实现，将所需的配置信息写在一个node节点上，然后所有的客户端服务去监听这个节点，一旦该节点node发生了变化，ZooKeeper就会将变化通知给每个客户端服务器

同时ZooKeeper也可以实现实时监控节点状态变化

#### 下载地址 ####

官网地址：

https://zookeeper.apache.org/

访问官网就可以下载所需版本的ZooKeeper的tar包

### ZooKeeper安装 ###

#### 本地模式安装 ####

在安装前需要有一些必须的准备：

因为ZooKeeper是由java开发的，**依赖机器的java环境**，所以在安装之前需要确定机器内已经安装有java

随后将tar包解压之后放入自己指定的目录下

**修改配置文件**

ZooKeeper的配置修改十分简洁，只需要更改一下dataDir的路径即可，ZooKeeper有默认的存储路径，但是还是建议将其目录修改为自己的目录

在zookeeper的cong目录下，有一个zoo\_sample.cfg ，从命名就能看出来这是为我们配置zookeeper提供了一个sample，我们可以将这个文件重命名然后更改

将配置文件中的dataDir路径指定为我们自己的路径即可

**zookeeper的操作**

1.  **启动zookeeper**
    
    在zookeeper的目录中有个bin目录，里面有zkServer.sh文件，就是启动文件件
    
        bin/zkServer.sh start
2.  **查看进程**
    
    启动之后可以查看进程是否已经启动，因为zookeeper是java开发的，属于一个java进程，所以可以使用 JPS命令查看进程是否启动
    
        jps
3.  **查看状态**
    
    同样是zkServer.sh文件的参数，使用status参数就可以查看状态
    
        bin/zkServer.sh status
4.  **启动客户端**
    
    zookeeper的服务端已经启动了，如果要操作zookeeper，就可以在客户端内操作，在bin目录下有一个客户端的命令zkCli.sh
    
        bin/zkCli.sh
5.  **退出客户端**
    
    和mysql和hive类似，可以使用quit退出客户端
    
        quit
6.  **停止服务器**
    
    同样是zkServer.sh文件的参数，使用stop参数就可以停止服务器
    
        bin/zkServer.sh stop

#### 配置文件 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70]

### ZooKeeper集群操作 ###

#### 集群操作 ####

**集群规划**

在测试中有三台服务器，在有三台服务器的情况下一般是都安装上ZooKeeper

根据实际经验，不同的服务器个数安装的zookeeper个数对应关系

<table> 
 <thead> 
  <tr> 
   <th align="center">服务器数</th> 
   <th align="center">zookeeper数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">3</td> 
   <td align="center">3</td> 
  </tr> 
  <tr> 
   <td align="center">10</td> 
   <td align="center">3</td> 
  </tr> 
  <tr> 
   <td align="center">20</td> 
   <td align="center">5</td> 
  </tr> 
  <tr> 
   <td align="center">100</td> 
   <td align="center">11</td> 
  </tr> 
  <tr> 
   <td align="center">200</td> 
   <td align="center">11</td> 
  </tr> 
 </tbody> 
</table>

集群规划的关系就如上所示，服务器的多少也有利有弊，并不是越多越好

服务器台数多，好处就是可以提高可靠性，坏处就是服务器数量太多，影响之间的通信，会加大通信延时

**解压安装**

将zookeeper的tar包解压到相应的文件夹，然后配置服务器编号

**配置服务器编号**

在zookeeper文件夹下创建一个zkData，新建一个myid文件，输入2，意思就是对应的server编号为2，注意这里**左右不能有空格，上下不能有空行**

mkdir zkData
    vim myid
    2

然后分发到其他的两台机器上，**分发之后注意其server对应的编号要修改**

**配置zookeeper.cfg文件**

将原先的zoo\_sample.cfg文件进行重新命名，将里面的存储路径dataDir的路径配置为自己的路径，然后再文件后面添加配置

server.2=hadoop102:2888:3888 
    server.3=hadoop103:2888:3888 
    server.4=hadoop104:2888:3888

配置参数解读  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70 1]

**启动集群**

bin/zkServer.sh start

分别将三台全部启动

#### 选举机制 ####

在zookeeper启动之后，会选举出一个Leader，Leader的选取机制：

分为两种：**第一次启动选举 和 非第一次启动选举**

**第一次启动选举：半数原则**

在服务器启动之后，每个机器都可以投出一张选票，在没选举出Leader之前都是投给自己，如果集群有两个以上的机器投票了，但是还是没有选出Leader，那么机器号小的就把选票投给机器号大的，知道选出Leader之后，则之后启动的服务器，不管机器号大小，全是Follower

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70 2]

**非第一次启动**

当zookeeper集群中的一台服务器出现以下两种情况之一，就会进入Leader选择

*  服务器初始化启动
 *  服务器运行期间无法和Leader保持连接

首先了解几个名词

**SID**：服务器ID。用来唯一标识一台ZooKeeper集群中的机器，每台机器不能重  
复，和myid一致。  
**ZXID**：事务ID。ZXID是一个事务ID，用来标识一次服务器状态的变更。在某一时刻，集群中的每台机器的ZXID值不一定完全一致，这和ZooKeeper服务器对于客户端“更新请求”的处理逻辑有关。  
**Epoch**：每个Leader任期的代号。没有Leader时同一轮投票过程中的逻辑时钟值是  
相同的。每投完一次票这个数据就会增加

非第一次启动时的选举机制就是按照这三个id进行选举  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70 3]

#### ZK集群的启动停止脚本 ####

在每次开启Zk的时候，因为是在三台机器上都装了，所以每次开启都要去三台机器上逐次开启，三台还可以接受，如果有五台，七台，十一台，就会相当麻烦，所以可以编写一个脚本用来启动和停止脚本

vim zk.sh

在脚本中编写内容

#!/bin/bash 
     
    case $1 in 
    "start"){
         
      for i in hadoop102 hadoop103 hadoop104 
      do 
            echo ---------- zookeeper $i 启动 ------------ 
       ssh  $i  "/opt/module/zookeeper-3.5.7/bin/zkServer.sh 
    start" 
      done 
    };; 
    "stop"){
         
      for i in hadoop102 hadoop103 hadoop104 
      do 
            echo ---------- zookeeper $i 停止 ------------     
       ssh  $i  "/opt/module/zookeeper-3.5.7/bin/zkServer.sh 
    stop" 
      done 
    };; 
    "status"){
         
      for i in hadoop102 hadoop103 hadoop104 
      do 
            echo ---------- zookeeper $i 状态 ------------     
       ssh  $i  "/opt/module/zookeeper-3.5.7/bin/zkServer.sh 
    status" 
      done 
    };; 
    esac

给脚本添加执行权限

chmod u+x zk.sh

脚本就编写完成了

脚本的使用

集群启动脚本

zk.sh start

集群停止脚本

zk.sh stop

#### 客户端命令后操作 ####

**命令行语法**

<table> 
 <thead> 
  <tr> 
   <th>命令基本语法</th> 
   <th>功能描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>help</td> 
   <td>显示所有操作命令</td> 
  </tr> 
  <tr> 
   <td>ls path</td> 
   <td>使用 ls 命令来查看当前 znode 的子节点 [可监听] <br>-w 监听子节点变化 <br>-s 附加次级信息</td> 
  </tr> 
  <tr> 
   <td>create</td> 
   <td>普通创建 <br>-s 含有序列 <br>-e 临时（重启或者超时消失）</td> 
  </tr> 
  <tr> 
   <td>get path</td> 
   <td>获得节点的值 [可监听] <br>-w 监听节点内容变化 <br>-s 附加次级信息</td> 
  </tr> 
  <tr> 
   <td>set</td> 
   <td>设置节点的具体值</td> 
  </tr> 
  <tr> 
   <td>stat</td> 
   <td>查看节点状态</td> 
  </tr> 
  <tr> 
   <td>delete</td> 
   <td>删除节点</td> 
  </tr> 
  <tr> 
   <td>deleteall</td> 
   <td>递归删除节点</td> 
  </tr> 
 </tbody> 
</table>

**节点的类型**

节点的类型有：

**持有、短暂、有序号、无序号**

*  **持久化目录节点**：客户端与Zookeeper断开连接后，该节点依旧存在
 *  **临时目录节点**：客户端与Zookeeper断开连接后，该节点被删除
 *  **持久化顺序编号目录节点**：客户端与Zookeeper断开连接后，该节点依旧存在，只是Zookeeper给该节点名称进行顺序编号
 *  **临时顺序编号目录节点**：客户端与Zookeeper 断开连接后，该节点被删除 ，只是  
    Zookeeper给该节点名称进行顺序编号。

**创建两个普通节点（永久节点+不带序号）**

create /lnnu "lnnu"
    create /gis "gis"

**获得节点的值**

get -s lnnu

**创建带序号的节点（永久节点+带序号）**

create -s /geog "geog"

如果原来没有序号节点，序号从 0 开始依次递增。如果原节点下已有 2 个节点，则再排序时从 2 开始，以此类推。

**创建短暂节点（短暂节点 + 不带序号 or 带序号）**

create -e prov "prov"

**修改节点的值**

set /lnnu "1951"

**监听器原理**

客户端注册监听它关心的目录节点，当目录节点发生变化（数据改变、节点删除、子目录节点增加删除）时，ZooKeeper 会通知客户端。监听机制保证 ZooKeeper 保存的任何的数据的任何改变都能快速的响应到监听了该节点的应用程序。

**节点的值变化的监听**

get -w /lnnu

如果修改lnnu的值，就会被监听到

**节点的子节点变化监听（路径变化）**

ls -w /lnnu

如果在lnnu节点下新增或者删除子节点，就会被监听到

**节点的删除与查看**

**删除节点**

delete /gis

**递归删除节点**

deleteall /lnnu

#### 客户端API操作：开发重点 ####

在进行客户端API操作的时候，要确保集群的ZooKeeper已经启动

##### IDEA环境搭建 #####

1.  创建一个maven工程
2.  添加pom文件
    
        <dependencies> 
          <dependency> 
           <groupId>junit</groupId> 
           <artifactId>junit</artifactId> 
           <version>RELEASE</version> 
          </dependency> 
         
          <dependency> 
           <groupId>org.apache.logging.log4j</groupId> 
           <artifactId>log4j-core</artifactId> 
           <version>2.8.2</version> 
           </dependency> 
         
          <dependency> 
           <groupId>org.apache.zookeeper</groupId> 
           <artifactId>zookeeper</artifactId> 
           <version>3.5.7</version> 
          </dependency> 
        </dependencies>
3.  将log4j.properties文件拷贝到项目根目录，在resource中新建一个文件，命名为log4j.properties，然后填入
    
        log4j.rootLogger=INFO, stdout   
        log4j.appender.stdout=org.apache.log4j.ConsoleAppender   
        log4j.appender.stdout.layout=org.apache.log4j.PatternLayout   
        log4j.appender.stdout.layout.ConversionPattern=%d  %p  [%c] 
        - %m%n   
        log4j.appender.logfile=org.apache.log4j.FileAppender   
        log4j.appender.logfile.File=target/spring.log   
        log4j.appender.logfile.layout=org.apache.log4j.PatternLayout   
        log4j.appender.logfile.layout.ConversionPattern=%d  %p  [%c] 
        - %m%n
4.  创建类，编写业务

##### 创建ZooKeeper客户端 #####

// 注意：逗号前后不能有空格 
    private static String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181"; 
     
      private static int sessionTimeout = 2000; 
      private ZooKeeper zkClient = null; 
     
      @Before 
      public void init() throws Exception {
         
     
      zkClient = new ZooKeeper(connectString, sessionTimeout, new 
    Watcher() {
         
     
        @Override 
        public void process(WatchedEvent watchedEvent) {
         
     
         // 收到事件通知后的回调函数（用户的业务逻辑） 
         System.out.println(watchedEvent.getType() + "--" 
    + watchedEvent.getPath()); 
     
         // 再次启动监听 
         try {
         
          List<String> children = zkClient.getChildren("/", 
    true); 
                        for (String child : children) {
         
                            System.out.println(child); 
                        } 
                        } catch (Exception e) {
         
          					e.printStackTrace(); 
         				} 
        			} 
       			}); 
      		} 
    }

##### 创建子节点 #####

// 创建子节点 
    @Test 
    public void create() throws Exception {
         
     
      // 参数 1：要创建的节点的路径； 参数 2：节点数据 ； 参数 3：节点权限 ；
    参数 4：节点的类型 
      String  nodeCreated  =  zkClient.create("/gis", 
    "shuaige".getBytes(),  Ids.OPEN_ACL_UNSAFE, 
    CreateMode.PERSISTENT); 
    }

##### 获取子节点，并监听节点变化 #####

// 获取子节点 
    @Test 
    public void getChildren() throws Exception {
         
     
      List<String> children = zkClient.getChildren("/", true); 
     
      for (String child : children) {
         
       System.out.println(child); 
      } 
     
      // 延时阻塞 
      Thread.sleep(Long.MAX_VALUE); 
    }

##### 判断Znode是否存在 #####

// 判断 znode 是否存在 
    @Test 
    public void exist() throws Exception {
         
    	Stat stat = zkClient.exists("/gis", false); 
     
      	System.out.println(stat == null ? "not exist" : "exist"); 
    }

### 服务器动态上下线监听案例 ###

#### 需求： ####

某分布式系统中，主节点可以有多台，可以动态上下线，任意一台客户端都能实时感知到主节点服务器的上下线。

**代码实现：**

服务端像ZooKeeper注册代码

package com.gis.zkcase1; 
    import java.io.IOException; 
    import org.apache.zookeeper.CreateMode; 
    import org.apache.zookeeper.WatchedEvent; 
    import org.apache.zookeeper.Watcher; 
    import org.apache.zookeeper.ZooKeeper; 
    import org.apache.zookeeper.ZooDefs.Ids; 
     
    public class DistributeServer {
         
     
     private  static  String  connectString  = 
    "hadoop102:2181,hadoop103:2181,hadoop104:2181"; 
     private static int sessionTimeout = 2000; 
     private ZooKeeper zk = null; 
     private String parentNode = "/servers"; 
      
     //  创建到 zk  的客户端连接 
     public void getConnect() throws IOException{
         
       
       zk = new ZooKeeper(connectString, sessionTimeout, new 
    Watcher() {
         
     
        @Override 
        public void process(WatchedEvent event) {
         
         } 
       }); 
     } 
      
     //  注册服务器 
     public void registServer(String hostname) throws Exception{
         
     
       String  create  =  zk.create(parentNode  +  "/server", 
    hostname.getBytes(),  Ids.OPEN_ACL_UNSAFE, 
    CreateMode.EPHEMERAL_SEQUENTIAL); 
       
       System.out.println(hostname +" is online "+ create); 
     } 
      
     //  业务功能 
     public void business(String hostname) throws Exception{
         
       System.out.println(hostname + " is working ..."); 
       
       Thread.sleep(Long.MAX_VALUE); 
     } 
      
     public static void main(String[] args) throws Exception {
         
       
       // 1  获取 zk  连接 
       DistributeServer server = new DistributeServer(); 
       server.getConnect(); 
       
       // 2  利用 zk  连接注册服务器信息 
       server.registServer(args[0]); 
       
       // 3  启动业务功能 
       server.business(args[0]); 
     } 
    }

客户端代码

package com.gis.zkcase1; 
    import java.io.IOException; 
    import java.util.ArrayList; 
    import java.util.List; 
    import org.apache.zookeeper.WatchedEvent; 
    import org.apache.zookeeper.Watcher; 
    import org.apache.zookeeper.ZooKeeper; 
     
    public class DistributeClient {
         
     
     private  static  String  connectString  = 
    "hadoop102:2181,hadoop103:2181,hadoop104:2181"; 
     private static int sessionTimeout = 2000; 
     private ZooKeeper zk = null; 
     private String parentNode = "/servers"; 
     
     //  创建到 zk  的客户端连接 
     public void getConnect() throws IOException {
         
     
       zk = new ZooKeeper(connectString, sessionTimeout, new 
    Watcher() {
        
    @Override 
        public void process(WatchedEvent event) {
         
     
         //  再次启动监听 
         try {
         
          getServerList(); 
         } catch (Exception e) {
         
          e.printStackTrace(); 
         } 
        } 
       }); 
     } 
     
     //  获取服务器列表信息 
     public void getServerList() throws Exception {
         
       
         // 1  获取服务器 子节点信息，并且对父节点进行监听 
      List<String> children = zk.getChildren(parentNode, true); 
     
          // 2  存储服务器信息列表 
       ArrayList<String> servers = new ArrayList<>(); 
       
          // 3  遍历所有节点，获取节点中的主机名称信息 
       for (String child : children) {
         
        byte[] data = zk.getData(parentNode + "/" + child, 
    false, null); 
     
        servers.add(new String(data)); 
       } 
     
          // 4  打印服务器列表信息 
       System.out.println(servers); 
     } 
     
     //  业务功能 
     public void business() throws Exception{
         
     
       System.out.println("client is working ..."); 
       Thread.sleep(Long.MAX_VALUE); 
     } 
     
     public static void main(String[] args) throws Exception {
         
     
       // 1  获取 zk  连接 
       DistributeClient client = new DistributeClient(); 
       client.getConnect(); 
     
       // 2  获取 servers  的子节点信息，从中获取服务器信息列表 
       client.getServerList(); 
     
       // 3  业务进程启动 
       client.business(); 
     } 
    }

### ZooKeeper 分布式锁案例 ###

**分布式锁：**

"进程 1"在使用该资源的时候，会先去获得锁，"进程 1"获得锁以后会对该资源保持独占，这样其他进程就无法访问该资源，"进程 1"用完该资源以后就将锁释放掉，让其  
他进程来获得锁， 那么通过这个锁机制， 我们就能保证了分布式系统中多个进程能够有序的访问该临界资源。那么我们把这个分布式环境下的这个锁叫作分布式锁。

#### 原生 Zookeeper 实现 分布式锁案例 ####

**分布式锁实现**

package com.gis.lock2; 
     
    import org.apache.zookeeper.*; 
    import org.apache.zookeeper.data.Stat; 
     
    import java.io.IOException; 
    import java.util.Collections; 
    import java.util.List; 
    import java.util.concurrent.CountDownLatch; 
     
    public class DistributedLock {
         
     
        // zookeeper server 列表 
        private  String  connectString  = 
    "hadoop102:2181,hadoop103:2181,hadoop104:2181"; 
        // 超时时间 
        private int sessionTimeout = 2000; 
     
        private ZooKeeper zk; 
     
        private String rootNode = "locks"; 
        private String subNode = "seq-"; 
        // 当前 client 等待的子节点 
        private String waitPath; 
     
        //ZooKeeper 连接 
        private CountDownLatch connectLatch = new CountDownLatch(1);
        //ZooKeeper 节点等待 
        private CountDownLatch waitLatch = new CountDownLatch(1); 
     
        // 当前 client 创建的子节点 
        private String currentNode; 
     
        // 和 zk 服务建立连接，并创建根节点 
        public  DistributedLock()  throws  IOException, 
    InterruptedException, KeeperException {
         
     
            zk = new ZooKeeper(connectString, sessionTimeout, new 
    Watcher() {
         
                @Override 
                public void process(WatchedEvent event) {
         
                    // 连接建立时, 打开 latch, 唤醒 wait 在该 latch 上的线程 
                    if  (event.getState()  == 
    Event.KeeperState.SyncConnected) {
         
                        connectLatch.countDown(); 
                    } 
     
                    // 发生了 waitPath 的删除事件 
                    if  (event.getType()  == 
    Event.EventType.NodeDeleted && event.getPath().equals(waitPath)) 
    {
         
                        waitLatch.countDown(); 
                    } 
                } 
            }); 
     
            // 等待连接建立 
            connectLatch.await(); 
     
            //获取根节点状态 
            Stat stat = zk.exists("/" + rootNode, false); 
     
            //如果根节点不存在，则创建根节点，根节点类型为永久节点 
            if (stat == null) {
         
                System.out.println("根节点不存在"); 
                zk.create("/"  +  rootNode,  new  byte[0], 
    ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); 
            } 
        } 
     
        // 加锁方法 
        public void zkLock() {
         
     
            try {
         
                //在根节点下创建临时顺序节点，返回值为创建的节点路径 
                currentNode = zk.create("/" + rootNode + "/" + subNode, 
    null, ZooDefs.Ids.OPEN_ACL_UNSAFE, 
                        CreateMode.EPHEMERAL_SEQUENTIAL); 
     
                // wait 一小会, 让结果更清晰一些 
                Thread.sleep(10); 
     
                // 注意, 没有必要监听"/locks"的子节点的变化情况 
                List<String> childrenNodes = zk.getChildren("/" + 
    rootNode, false); 
     
                // 列表中只有一个子节点, 那肯定就是 currentNode , 说明
    client 获得锁 
                if (childrenNodes.size() == 1) {
         
                    return; 
                } else {
         
                    //对根节点下的所有临时顺序节点进行从小到大排序 
                    Collections.sort(childrenNodes); 
     
                    //当前节点名称 
                    String thisNode = currentNode.substring(("/" + 
    rootNode + "/").length()); 
                    //获取当前节点的位置 
                    int index = childrenNodes.indexOf(thisNode); 
     
                    if (index == -1) {
         
                        System.out.println("数据异常"); 
                    } else if (index == 0) {
         
                        // index == 0, 说明 thisNode 在列表中最小, 当前
    client 获得锁 
                        return; 
                    } else {
         
                        // 获得排名比 currentNode 前 1 位的节点 
                        this.waitPath = "/" + rootNode + "/" + 
    childrenNodes.get(index - 1); 
     
                        // 在 waitPath 上注册监听器, 当 waitPath 被删除时, 
    zookeeper 会回调监听器的 process 方法 
                        zk.getData(waitPath, true, new Stat()); 
                        //进入等待锁状态 
                        waitLatch.await(); 
     
                        return; 
                    } 
                } 
            } catch (KeeperException e) {
         
                e.printStackTrace(); 
            } catch (InterruptedException e) {
         
                e.printStackTrace(); 
            } 
        } 
     
        // 解锁方法 
        public void zkUnlock() {
         
            try {
         
                zk.delete(this.currentNode, -1); 
            } catch (InterruptedException | KeeperException e) {
         
                e.printStackTrace(); 
            } 
        } 
    }

#### Curator 框架实现分布式锁案例 ####

**原生的 Java API 开发存在的问题**  
1、会话连接是异步的，需要自己去处理。比如使用 CountDownLatch  
2、Watch 需要重复注册，不然就不能生效  
3、开发的复杂性还是比较高的  
4、不支持多节点删除和创建。需要自己去递归  
**Curator 是一个专门解决分布式锁的框架， 解决了原生Java API 开发分布式遇到的问题。**  
详情请查看官方文档：https://curator.apache.org/index.html

##### Curator 案例实操 #####

1.  **添加依赖**
    
        <dependency> 
            <groupId>org.apache.curator</groupId> 
            <artifactId>curator-framework</artifactId> 
            <version>4.3.0</version> 
        </dependency> 
        <dependency> 
            <groupId>org.apache.curator</groupId> 
            <artifactId>curator-recipes</artifactId> 
            <version>4.3.0</version> 
        </dependency> 
        <dependency> 
            <groupId>org.apache.curator</groupId> 
            <artifactId>curator-client</artifactId> 
            <version>4.3.0</version> 
        </dependency>
2.  **代码实现**
    
        package com.gis.lock; 
         
        import org.apache.curator.RetryPolicy; 
        import org.apache.curator.framework.CuratorFramework; 
        import org.apache.curator.framework.CuratorFrameworkFactory; 
        import 
        org.apache.curator.framework.recipes.locks.InterProcessLock; 
        import 
        org.apache.curator.framework.recipes.locks.InterProcessMutex; 
        import org.apache.curator.retry.ExponentialBackoffRetry; 
         
        public class CuratorLockTest {
               
         
            private String rootNode = "/locks"; 
            // zookeeper server 列表 
            private  String  connectString  = 
        "hadoop102:2181,hadoop103:2181,hadoop104:2181"; 
         
            // connection 超时时间 
            private int connectionTimeout = 2000; 
         
            // session 超时时间 
            private int sessionTimeout = 2000; 
         
            public static void main(String[] args) {
               
         
                new CuratorLockTest().test(); 
            } 
         
            // 测试 
            private void test() {
               
         
                // 创建分布式锁 1 
                final  InterProcessLock  lock1  =  new 
        InterProcessMutex(getCuratorFramework(), rootNode); 
         
                // 创建分布式锁 2 
                final  InterProcessLock  lock2  =  new 
        InterProcessMutex(getCuratorFramework(), rootNode); 
         
                new Thread(new Runnable() {
               
                    @Override 
                    public void run() {
               
                        // 获取锁对象 
                        try {
               
                            lock1.acquire(); 
                            System.out.println("线程 1 获取锁"); 
                            // 测试锁重入 
                            lock1.acquire(); 
                            System.out.println("线程 1 再次获取锁"); 
                            Thread.sleep(5 * 1000); 
                            lock1.release(); 
                            System.out.println("线程 1 释放锁"); 
                            lock1.release(); 
                            System.out.println("线程 1 再次释放锁"); 
                        } catch (Exception e) {
               
                            e.printStackTrace(); 
                        } 
                    } 
                }).start(); 
                new Thread(new Runnable() {
               
                    @Override 
                    public void run() {
               
                        // 获取锁对象 
                        try {
               
                            lock2.acquire(); 
                            System.out.println("线程 2 获取锁"); 
                            // 测试锁重入 
                            lock2.acquire();
                            System.out.println("线程 2 再次获取锁"); 
                            Thread.sleep(5 * 1000); 
                            lock2.release(); 
                            System.out.println("线程 2 释放锁"); 
                            lock2.release(); 
                            System.out.println("线程 2 再次释放锁"); 
                        } catch (Exception e) {
               
                            e.printStackTrace(); 
                        } 
                    } 
                }).start(); 
            } 
         
            // 分布式锁初始化 
            public CuratorFramework getCuratorFramework (){
               
         
                //重试策略，初试时间 3 秒，重试 3 次 
                RetryPolicy policy = new ExponentialBackoffRetry(3000, 3); 
         
                //通过工厂创建 Curator 
                CuratorFramework  client  = 
        CuratorFrameworkFactory.builder() 
                        .connectString(connectString) 
                        .connectionTimeoutMs(connectionTimeout) 
                        .sessionTimeoutMs(sessionTimeout) 
                        .retryPolicy(policy).build(); 
         
                //开启连接 
                client.start(); 
                System.out.println("zookeeper 初始化完成..."); 
                return client; 
            } 
         
        }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/a65850f6efb1412ebd39405b6123c8f0.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/6b9b3df5ed234469aba5b343884cbd83.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/4dbc093789fc404f9580f233c30c35b7.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/87012b94e5c84914ab7422b8c85fa996.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA==,size_16,color_FFFFFF,t_70