Zookeeper简述

2018-06-18 00:20:48来源：未知阅读 ()

提到Zookeeper,不得不先聊聊分布式协调技术

一、什么是分布式协调技术

　　分布式协调技术主要用来解决分布式环境当中多个进程之间的同步控制，让他们有序的去访问某种临界资源，防止造成"脏数据"的后果。

　　那么怎么对这些进程进行调度呢？

　　这时候我们就需要一个协调器，来让他们有序的来访问这个资源。这个协调器就是我们经常提到的那个锁。通过这个锁机制，我们就能保证了分布式系统中多个进程能够有序的访问该临界资源。那么我们把这个分布式环境下的这个锁叫作分布式锁。但是因为其运行所在的环境存在网络延迟等不可靠因素的，导致对数据的处理存在许多困难。目前处理分布式协调技术比较好的有Chubby(Google产品，收费)和Zookeeper(Apache产品，免费)。

二、什么是Zookeeper

　　ZooKeeper是一种为分布式应用所设计的高可用、高性能且一致的开源协调服务，它提供了一项基本服务：分布式锁服务。由于ZooKeeper的开源特性，后来我们的开发者在分布式锁的基础上，摸索了出了其他的使用方法：配置维护、组服务、分布式消息队列、分布式通知/协调等。

　　ZooKeeper性能上的特点决定了它能够用在大型的、分布式的系统当中。从可靠性方面来说，它并不会因为一个节点的错误而崩溃。除此之外，它严格的序列访问控制意味着复杂的控制原语可以应用在客户端上。ZooKeeper在一致性、可用性、容错性的保证，也是ZooKeeper的成功之处。

三、Zookeeper特性

　　1、全局数据一致：每个server保存一份相同的数据副本，client无论连接到哪个server,展示的数据都是一致性的，当客户端操作一个节点的文件时，其他两个节点会随之更新，这样保证了全局数据的一致性。

　　2、可靠性：如果消息被其中一台服务接受，那么将被所有的服务器接受。

　　3、顺序性：包括全局有序和偏序两种：全局有序是指如果在一台服务器上消息a在消息b前发布，则在所有Server上消息a都将在消息b前被发布；偏序是指如果一个消息b在消息a后被同一个发送者发布，a必将排在b前面。

　　4、数据更新原子性：一次数据更新要么成功，要么失败。

四、Zookeeper部署

　　1、下载相对应的jar包

wget http://mirror.bit.edu.cn/apache/zookeeper/stable/zookeeper-3.4.12.tar.gz

　　2、安装到指定目录

tail -zxvf zookeeper-3.4.12.tar.gz

　　3、重命名配置文件

[oracle@bogon java]$ cd zookeeper-3.4.12/
[oracle@bogon zookeeper-3.4.12]$ cd conf
[oracle@bogon conf]$ ll
总用量 16
-rw-rw-r--. 1 oracle oracle  535 3月  27 12:32 configuration.xsl
-rw-rw-r--. 1 oracle oracle 2161 3月  27 12:32 log4j.properties
-rw-rw-r--. 1 oracle oracle  922 3月  27 12:32 zoo_sample.cfg
[oracle@bogon conf]$cp zoo_sample.cfg zoo.cfg

　　zookeeper默认读取zoo.cfg配置文件

　　其实到这单机版的zookeeper就算安装完毕了，如果为了方便管理，可以为其配置环境变量，这里不做演示

　　4、启动

[root@bogon bin]# ./zkServer.sh start    #启动服务端
[root@bogon bin]# ./zkServer.sh status   #查看状态
[root@bogon bin]# ./zkCli.sh             #启动客户端

五、关于zookeeper数据模型

　　在zookeeper下，其文件存储类似于树一样具有层次结构，每个文件节点被称之为Znode

　　1、每个Znode具有原子性

　　2、每个Znode存储数据大小具有限制

　　3、Znode通过路径引用，但是其路径必须是绝对的，因此他们必须由斜杠字符来开头

　　4、节点类型包含临时节点和永久节点。临时节点会话结束就自动删除，临时节点不允许拥有子节点。永久节点的生命周期不依赖与会话。

　　5、Znode具有序列化特性。随着其创建，其附带一个序列号。此序列号对于此及节点的父节点是唯一的，这样便记录了每个子节点创建的先后顺序。

六、关于Zookeeper相关命令

　如果直接输入zkCil.sh 他会自动匹配本机的zookeeper客户端，Zookeeper本质就是一个小型的文件存储系统。

　启动一般语法：./zkCli.sh -timeout 0 -r -server ip:port

如：./zkCli.sh -timeout 3000 -server h1:2181，表示连接到主机h1 超时时间为3秒

　1、查询

　 ls 　　语法：ls path [watch] 列出指定节点

[zk: localhost:2181(CONNECTED) 4] ls /      #遍历根目录
[zookeeper, QQQs, test]
[zk: localhost:2181(CONNECTED) 6] ls /test  #遍历根目录下子节点test
[test1]

　 stat　　语法：stat path [watch]

　列出指定节点的状态信息，或者说是元数据

[zk: localhost:2181(CONNECTED) 8] stat /
cZxid = 0x0        　　　　　　　　　　　　　 #节点被创建时的事务ID
ctime = Thu Jan 01 08:00:00 CST 1970    #节点被创建的时间
mZxid = 0x0                             #最近一次更新的时的事务ID
mtime = Thu Jan 01 08:00:00 CST 1970    #最近一次更新的时间
pZxid = 0x1a5                           #该节点的子节点列表最近一次被修改的事务ID
cversion = 99     　　　　　　　　　　　　　　#子节点的版本号
dataVersion = 0  　　　　　　　　　　　　　　 #数据版本
aclVersion = 0      　　　　　　　　　　　　 #ACL版本号
ephemeralOwner = 0x0      　　　　　　　　 #创建临时节点的事务ID，如果是持久节点，则该节点为0x0
dataLength = 0    　　　　　　　　　　　　   #当前节点的数据长度
numChildren = 3            　　　　　　　  #当前节点的子节点数目

　　get　　语法：get path [watch]

　　列出指定节点的数据

[zk: localhost:2181(CONNECTED) 10] get /test
demo

　　ls2 　　语法：ls2 path [watch]

　　是ls的升级版，列出子节点的同时列出节点的状态信息

[zk: localhost:2181(CONNECTED) 11] ls2 /test
[test1]
cZxid = 0x1a5
ctime = Thu Jun 07 08:26:10 CST 2018
mZxid = 0x1a5
mtime = Thu Jun 07 08:26:10 CST 2018
pZxid = 0x1a6
cversion = 1
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 4
numChildren = 1

　　history　　查看历史

　　History命令可以查看先前执行过的所有的命令，它一般与redo配合使用

[zk: localhost:2181(CONNECTED) 5] history
0 - ls -l
1 - ls /
2 - delquota -n /testquota
3 - ls /
4 - listquota /testquota
5 - history

　　redo　　重新执行先前命令，根据行数执行

[zk: localhost:2181(CONNECTED) 6] redo 1  #redo重新执行先前命令，根据行数执行
[testquota, zookeeper, hellozk]

　　2、创建

　　create　　语法：create [-s] [-e] path data acl

　　其中：括号中时可选的，s表示创建永久节点，e表示创建临时节点，acl表示访问控制列表

[zk: localhost:2181(CONNECTED) 2] create /test demo
Created /test
[zk: localhost:2181(CONNECTED) 5] create /test/test1 demo1
Created /test/test1

　　3、修改

　　set　　语法：set path data [version]

[zk: localhost:2181(CONNECTED) 12] ls /
[zookeeper, QQQs, test]
[zk: localhost:2181(CONNECTED) 13] set /test demo2
cZxid = 0x1a5
ctime = Thu Jun 07 08:26:10 CST 2018
mZxid = 0x1a7
mtime = Thu Jun 07 08:45:54 CST 2018　　#修改时间与修改时间不一致
pZxid = 0x1a6　　
cversion = 1　　
dataVersion = 1　　　　　　　　　　　　　　　 #数据版本号为1,表示被更改一次
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 5
numChildren = 1

　　4、删除

　　delete　　语法：delete path [version]　　

　　只能删除不含子节点的节点

[zk: localhost:2181(CONNECTED) 12] ls /
[zookeeper, QQQs, test]
[zk: localhost:2181(CONNECTED) 14] delete /QQQs
[zk: localhost:2181(CONNECTED) 15] ls /
[zookeeper, test]

　　rmr　　语法：rmr path

　　能递归删除节点

[zk: localhost:2181(CONNECTED) 15] ls /
[zookeeper, test]
[zk: localhost:2181(CONNECTED) 16] rmr /test
[zk: localhost:2181(CONNECTED) 17] ls / 
[zookeeper]

　　5、增加限制

　　setquota　　语法：setquota -n | -b val path

　　其中：n表示子节点的最大个数；b表示数据值的最大长度；val表示子节点最大个数或者数据值的最大长度；path表示节点路径

[zk: localhost:2181(CONNECTED) 30] create /testquota 123    #创建具有限制属                                                              性节点
Created /testquota
[zk: localhost:2181(CONNECTED) 35] setquota -n 3 /testquota #设置最大子节点为3                                                               数为3
Comment: the parts are option -n val 3 path /testquota   
[zk: localhost:2181(CONNECTED) 36] listquota /testquota
absolute path is /zookeeper/quota/testquota/zookeeper_limits
Output quota for /testquota count=3,bytes=-1  　　　　　　　　　#count：子节点最大数  byte：数据长度（-1表示没有限制）
Output stat for /testquota count=1,bytes=3  　　　　　　　　　　 #count：当前子节点数（包含自己，1表示当前他没有子节点）

　　注意：如果创建的节点数超过了限制数，创建过程中不会报警告，但是日志中会显示超额

2018-05-05 17:03:56,025 [myid:3] - WARN  [CommitProcessor:3:DataTree@302] - Quota exceeded: /testquota count=5 limit=3
Delquota

　　删除节点限制

[zk: localhost:2181(CONNECTED) 2] delquota -n /testquota  #删除限制
[zk: localhost:2181(CONNECTED) 4] listquota /testquota
absolute path is /zookeeper/quota/testquota/zookeeper_limits
Output quota for /testquota count=-1,bytes=-1 　　　　　　　　#此时显示-1表示没有限制条件
Output stat for /testquota count=5,bytes=7

七、关于Zookeeper集群

　　Zookeeper集群搭建指的是Zookeeper分布式模拟安装。通常由2n+1台服务器组成。这是因为为了保证leader选举(基于Paxos算法的实现)能够得到多数的支持，所以Zookeeper集群的数量一般为奇数。

　　1、编辑相对应的配置文件

[root@bogon conf]# pwd
/usr/java/zookeeper-3.4.12/conf
[root@bogon conf]# vim zoo.cfg

　　2、配置相关数据

　　1) 指定数据存储目录

dataDir=/usr/data/zkdata        #指定数据存储目录

　　2) 添加配置Zookeeper服务器的地址即编号

##(心跳端口、选举端口)
server.1=jiaxianseng.host:2888:3888 
server.2=jiaxianseng.host1:2888:3888
server.3=jiaxianseng.host2:2888:3888

　　3、创建数据存储目录，在虚拟机中创建相对应的编号

[root@localhost conf]# mkdir -p /usr/data/zkdata
[root@localhost conf]#cd /usr/data/zkdata
[root@localhost zkdata]#touch myid
[root@localhost zkdata]# echo 1 >myid      #此表示选举当前第一台主机为leader

　　4、分发到另外两台机器

$scp -r zookeeper-3.4.12/ oracle@jiaxianseng.host1:/usr/java/
$scp -r zookeeper-3.4.12/ oracle@jiaxianseng.host2:/usr/java/

　　5、分别开启zookeeper，此时第一台服务器当选为leader，其创建的节点另外两台可以收到

　　扩展：如果在本机上玩伪集群，需要注意：

　　1) 在当前文件夹下需要进行分包配置，设定为三台zookeeper机器

[oracle@localhost zookeeper-3.4.12]$ ll
总用量 12
drwxr-xr-x 10 root root 4096 5月   5 14:40 zk1
drwxr-xr-x 10 root root 4096 5月   5 14:42 zk2
drwxr-xr-x 10 root root 4096 5月   5 12:46 zk3

　　2) 配置文件设置

　　因为是在本机上玩，三台端口号应该不同

clientPort=2181

八、Zookeeper监听机制　

　　Zookeeper提供了分布式数据发布/订阅功能。它允许客户端向服务端注册一个Watcher监听。当服务端一些时间触发了这个Watcher，那么就会向指定客户端发送一个时间通知实现分布式的通知功能，其中节点的增删改都可以触发事件。

　　值得注意的是：Zookeeper监听机制严格按照先注册再监听顺序，且触发事件监听是一次性的。触发一次发送回调事件情况后，下次触发不会进行回调，需要重新注册监听。

　　具体实现如下：

　1) 玩监听：前提是先得支持监听机制；其次是要注册监听，使用help命令进行查看

    [zk: localhost:2181(CONNECTED) 7] help   #使用help命令查看哪行命令支                                                持监听
　　 ZooKeeper -server host:port cmd args
    connect host:port
    get path [watch]
    ls path [watch]
    stat path [watch]

　　2) 先注册监听

[zk: localhost:2181(CONNECTED) 8] create /watchtest 123    #先注册监听
Created /watchtest

　　3) 查看是否被监听

[zk: localhost:2181(CONNECTED) 10] get /watchtest watch  #此节点被监听

　　4) 利用第二台机器改变节点数据

[zk: localhost:2181(CONNECTED) 0] set /watchtest 456789

　　5) 查看第一台机器返回的信息

WATCHER::
WatchedEvent state:SyncConnected type:NodeDataChanged path:/watchtest

　　此时第一台会收到节点被改变的提示，但是当节点再次被其他机器改变时

　　第一台机器不会收到任何信息，说明监听只会被触发一次。如果想再次收到监听信息，只能重新注册监听

九、关于Zookeeper Java API

　　1) 创建maven工程，并导入约束

  <!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.12</version>
</dependency>

　　2) 编写测试类，连接zookeeper，并创建节点

public class TestZKClient {
    public static void main(String[] args) throws Exception{  //main快捷：psvm
         //构造JAVA zookeeper客户端
        //参数：1.连接ip+端口（可配置多个，用分号隔开）  2.time连接超时时间：默认值为30000
        ZooKeeper zk=new ZooKeeper("192.168.174.133:2181,192.168.174.133:2182",30000,new Watcher(){

            //这里就是事件通知的回调方法
            public void process(WatchedEvent event) {
                System.out.println("事件通知类型"+event.getState());
                System.out.println("事件发生类型"+event.getType());
                System.out.println("事件发生路径"+event.getPath());
            }
        } );
        /**
         * 参数1：节点名 ；参数2：数据 ; 参数3：acl权限控制，这里采用默认值 ;参数4:创建节点类型：这里是持久序列化节点
         */
        zk.create("/myCirls","性感的".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
                zk.close();

    }
}

十、关于Zookeper分布式锁应用

　　分布式锁，这个主要得益于Zookeeper保证了数据的强一致性。锁服务可以分为两类，一个保持独占，另一个是控制时序。

　　应用：在分布式环境高并发场景下，生产有一定业务含义的唯一的订单编号

　　1、编写服务类：

/**
 * 订单编号服务
 * @author Administrator
 *
 */
public class OrderCodeGenerator {
    //自增长序列
    private static int i=0;
    //按照“年-月-日-小时-分钟-秒-自增长序列”的规则生成订单编号
    public String getOrderCode(){
        Date date=new Date();
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss-");
        return sdf.format(date)+ ++i;
    }
    public static void main(String[] args) {
        OrderCodeGenerator ong=new OrderCodeGenerator();
        for(int i=0;i<10;i++){
            System.out.println(ong.getOrderCode());
        }
    }
}

　　2、编写接口

/**
 * 定义订单服务接口
 * @author Administrator
 *
 */
public interface OrderService {
    void createOrder();
}

　　3、定义实现类

public class OrderServiceImpl implements OrderService{
    //定义为静态变量，保证订单号唯一
    private static OrderCodeGenerator ocg=new OrderCodeGenerator();
    //创建订单接口
    @Override
    public void createOrder() {
        // TODO Auto-generated method stub
        String orderCode=null;
        //获取订单号
        orderCode=ocg.getOrderCode();
        System.out.println(Thread.currentThread().getName()+"========"+orderCode);
    }

}

　　4、定义线程模拟多线程创建订单

public class DistrbutDemo {
    public static void main(String[] args) {
        //模拟多个并发创建订单
        //并发数
        int currs=10;
        //方式一：定义一个循环屏障：用于祖塞当前线程的，设置的参数为参与线程数，能保证设置每个线程统一完成每段步骤，
        //如线程一完成后进入等待，接着线程二完成后进入，等待其余线程完成，才能进入下一步
        final CyclicBarrier cb=new CyclicBarrier(currs);
        /*方式二：定义一个倒计数储存器：用于等待n个条件到达，每个线程完成数值减一
        CountDownLatch cdl=new CountDownLatch(currs);
        cdl.countDown();
        cdl.await();*/
        for(int i=0;i<currs;i++){
            new Thread(new Runnable() {
                
                @Override
                public void run() {
                    //模拟创建订单
                    OrderService os=new OrderServiceImpl();
                    //穿插线程阻塞
                    try {
                        cb.await();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    os.createOrder();
                }    
            }).start();
        }
    }
}

　　此时运行代码，可能会出现没有10这个订单号（创建了相同的订单，说明多线程编程下出现了不安全的情况，此时应该加锁）

打印结果如下：

Thread-5========2018-06-06-10-30-25-1
Thread-4========2018-06-06-10-30-25-6
Thread-3========2018-06-06-10-30-25-2
Thread-6========2018-06-06-10-30-25-8
Thread-0========2018-06-06-10-30-25-5
Thread-7========2018-06-06-10-30-25-4
Thread-8========2018-06-06-10-30-25-3
Thread-9========2018-06-06-10-30-25-9
Thread-1========2018-06-06-10-30-25-2
Thread-2========2018-06-06-10-30-25-7

　　5、方式一，加同步锁

public class OrderServiceImpl implements OrderService{
    //定义为静态变量，保证订单号唯一
    private static OrderCodeGenerator ocg=new OrderCodeGenerator();
    //创建订单接口
    @Override
    public void createOrder() {
        // TODO Auto-generated method stub
        String orderCode=null;
        //加同步锁：保证线程安全
        synchronized (ocg) {
            //获取订单号
            orderCode=ocg.getOrderCode();
        }
        System.out.println(Thread.currentThread().getName()+"========"+orderCode);
    }

}

　　注意：这里同步锁内参数不能使用this，因为在DistrbutDemo类中每次调用线程都重新new了一次，锁的不是同一个对象，其不带加锁的目的(获取的不是同一个对象的锁)，而用ocg是因为它是静态变量，获取的是同一个对象的锁

　　方式二：加锁lock

public class OrderServiceImpl implements OrderService{
    //定义为静态变量，保证订单号唯一
    private static OrderCodeGenerator ocg=new OrderCodeGenerator();
    //使用lock一定设置为静态变量，保证每个线程竞争的是同一把锁
    private static Lock lock=new ReentrantLock();
    //创建订单接口
    @Override
    public void createOrder() {
        // TODO Auto-generated method stub
        String orderCode=null;
        try{//防止出现异常后锁不能释放，所以加try/catch
        lock.lock();
        orderCode=ocg.getOrderCode();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
        //记得释放锁
        lock.unlock();
        }
        System.out.println(Thread.currentThread().getName()+"========"+orderCode);
    }
}

　　此时运行代码，不会出现重复的订单，是个完整的创建了10个订单

　　分析：以上代码确实能够保证线程安全，但是此只能在单机下玩，如果将服务放在多台机器上调用，这里需要引入分布式锁。

　　6、分布式锁实现的技术

　　基于数据库实现分布式锁：

　　　　性能较差，容易出现单点故障

　　　　锁没有失效时间，容易死锁

　　　　非阻塞式的

　　　　不可重入

　　基于缓存实现分布式锁

　　　　锁没有失效时间，容易死锁

　　　　非阻塞式的

　　　　不可重入

　　基于Zookeeper实现分布式锁

　　　　实现相对简单

　　　　可靠性高

　　　　性能较差

　　具体实现如下：

　　7、引入zk客户端依赖

<!--对zookeeper客户端进行了封装 -->
        <groupId>com.101tec</groupId>
        <artifactId>zkclient</artifactId>
        <version>0.10</version>
</dependency>

　　8、编写序列化类

public class MyZkSerializer implements ZkSerializer{
    String charset="UTF-8";
    //反序列化
    @Override
    public Object deserialize(byte[] bytes) throws ZkMarshallingError {
        // TODO Auto-generated method stub
        try {
            return new String(bytes,charset);
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            throw new ZkMarshallingError(e);
        }
    }
    //序列化
    @Override
    public byte[] serialize(Object obj) throws ZkMarshallingError {
        // TODO Auto-generated method stub
        try {
            return String.valueOf(obj).getBytes(charset);
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            throw new ZkMarshallingError(e);
        }
    }

}

　　9、编写zk连接监听程序

public class ZkWatcherDemo {
    public static void main(String[] args) {
        ZkClient client=new ZkClient("192.168.174.128:2181");
        client.setZkSerializer(new MyZkSerializer());
        client.subscribeDataChanges("/testWatch", new IZkDataListener() {
            
            @Override
            public void handleDataDeleted(String dataPath) throws Exception {
                System.out.println("----监听到节点被删除..");
                
            }
            
            @Override
            public void handleDataChange(String dataPath, Object data) throws Exception {
                // TODO Auto-generated method stub
                System.out.println("----监听到数据变为："+data);
            }
        });
        try {
            //为了方便查看，等待2分钟
            Thread.sleep(2 * 60 * 1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

　　此时如果更改testWatch值，控制台会打印监听的值
　　----监听到数据变为：55

　　10、Zookeeper分布式锁实现：

　　1) 定义分布式锁：

//定义分布式锁
public class ZKDistributeLock implements Lock{
    /**
     * 利用zookeeper的同父子节点不可重名的特点来实现分布式锁
     * 加锁的规则：去创建指定名称的节点，如果能创建成功，则获得锁(加锁成功)，如果节点已存在，就标识锁被别人获取了 
     *             你就得阻塞，等待
     * 锁释放规则：删除指定名称的节点
     */
    private String LockPath;
    private ZkClient client;
    public ZKDistributeLock(String lockPath) {
        super();
        LockPath = lockPath;
        client=new ZkClient("192.168.174.128:2181");
        client.setZkSerializer(new MyZkSerializer());
    }

    @Override
    public boolean tryLock() {
        try{
            this.client.createPersistent(LockPath);//创建永久节点
        }catch(ZkNodeExistsException e){
            return false;    
        }
        return true;
    }
    
    @Override
    public void lock() {
        if(!tryLock()){
            //阻塞等待
            waitForLock();
            //再次尝试加锁
            lock();
        }    
    }
    
    private void waitForLock() {
        //怎么让自己阻塞
        final CountDownLatch cdl=new CountDownLatch(1);
        //注册watch,好通知自己什么时候被唤醒
        IZkDataListener listener=new IZkDataListener() {
            
            @Override
            public void handleDataDeleted(String dataPath) throws Exception {
                System.out.println("----监听到节点被删除..");
                cdl.countDown();
            }
            
            @Override
            public void handleDataChange(String dataPath, Object data) throws Exception {
                // TODO Auto-generated method stub
                System.out.println("----监听到数据变为："+data);
            }
        };
        //注册该事件
        client.subscribeDataChanges(LockPath, listener);
        //这里得判断节点是否存在，否则会永久阻塞
        if(this.client.exists(LockPath)){
            try {
                cdl.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        try{
            cdl.await();
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        client.unsubscribeDataChanges(LockPath, listener);
    }

    @Override
    public void unlock() {
        //删除节点
        //this.client.deleteRecursive(arg0)表示递归删除
        this.client.delete(this.LockPath);
    }
    
    @Override
    public void lockInterruptibly() throws InterruptedException {
        // TODO Auto-generated method stub
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit)
            throws InterruptedException {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public Condition newCondition() {
        // TODO Auto-generated method stub
        return null;
    }

}

　　2) 调用分布式锁

public class OrderServiceImpl implements OrderService{
    //定义为静态变量，保证订单号唯一
    private static OrderCodeGenerator ocg=new OrderCodeGenerator();
    //使用lock一定设置为静态变量，保证每个线程竞争的是同一把锁
    private static Lock lock=new ZKDistributeLock("/testW");
    //创建订单接口
    @Override
    public void createOrder() {
        // TODO Auto-generated method stub
        String orderCode=null;
        try{//防止出现异常后锁不能释放，所以加try/catch
        lock.lock();
        orderCode=ocg.getOrderCode();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
        //记得释放锁
        lock.unlock();
        }
        System.out.println(Thread.currentThread().getName()+"========"+orderCode);
    }
}

打印结果如下：

log4j:WARN No appenders could be found for logger (org.I0Itec.zkclient.ZkConnection).
log4j:WARN No appenders could be found for logger (org.I0Itec.zkclient.ZkEventThread).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
Thread-4========2018-06-07-10-52-29-1
----监听到节点被删除..
----监听到数据变为：null
Thread-7========2018-06-07-10-52-29-2
----监听到节点被删除..
----监听到数据变为：null
Thread-9========2018-06-07-10-52-29-3
----监听到节点被删除..
----监听到数据变为：null
Thread-1========2018-06-07-10-52-29-4
----监听到节点被删除..
----监听到数据变为：null
Thread-3========2018-06-07-10-52-29-5
----监听到节点被删除..
----监听到数据变为：null
Thread-8========2018-06-07-10-52-29-6
----监听到节点被删除..
----监听到节点被删除..
----监听到数据变为：null
Thread-0========2018-06-07-10-52-29-7
----监听到节点被删除..
----监听到数据变为：null
Thread-2========2018-06-07-10-52-29-8
----监听到节点被删除..
----监听到数据变为：null
Thread-6========2018-06-07-10-52-29-9
----监听到节点被删除..
----监听到数据变为：null
Thread-5========2018-06-07-10-52-29-10
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..
----监听到节点被删除..

弊端问题：惊群效应

　　1、每次唤醒操作将所有线程唤醒了，其中一个抢到锁后，其他没抢到的又将进入阻塞等待状态

　　2、客户端无故接受了很多与自己无关的事件通知

　　3、利用持久节点创建的锁存在死锁的可能性！(当加锁后突然业务重启，释放锁未执行)　

在集群规模较大的环境中带来的危害：

　　1、巨大的服务器性能损耗　　2、网络冲击　　3、可能造成宕机

如打出很多----监听到节点被删除..这句话

　　解决：采用创建顺序节点

　　改进创建的是临时顺序节点，每次都是最小的节点获得锁，其下一个节点(更小)注册watcher

　　重写分布式锁(升级版)

//定义分布式锁
public class ZKDistributeImproveLock implements Lock {
    /**
     * 利用zookeeper的同父子节点不可重名的特点来实现分布式锁
     * 加锁的规则：去创建指定名称的节点，如果能创建成功，则获得锁(加锁成功)，如果节点已存在，就标识锁被别人获取了 你就得阻塞，等待
     * 锁释放规则：删除指定名称的节点
     */
    private String LockPath;
    private ZkClient client;
    // 需要将路径设置为ThreadLocal类型，否则不能被线程并发去使用
    private ThreadLocal<String> currentPath = new ThreadLocal<String>();
    private ThreadLocal<String> beforePath = new ThreadLocal<String>();

    public ZKDistributeImproveLock(String lockPath) {
        super();
        LockPath = lockPath;
        client = new ZkClient("192.168.174.128:2181");
        client.setZkSerializer(new MyZkSerializer());

        if (!this.client.exists(LockPath)) {
            this.client.createPersistent(LockPath);// 先创建永久节点
        }

    }

    @Override
    public boolean tryLock() {
        if (this.currentPath.get() == null) {
            // 注意：加锁时创建的是临时顺序节点
            currentPath.set(this.client.createEphemeralSequential(LockPath
                    + "/", "aaa"));
        }
        // 获得所有的子节点
        List<String> children = this.client.getChildren(LockPath);
        // 进行下排序
        Collections.sort(children);

        // 判断当前节点是否是最小的
        if (currentPath.get().equals(LockPath + "/" + children.get(0))) {
            return true;
        } else {
            // 获取前一个节点
            // 得到字节的索引号
            int curIndex = children.indexOf(currentPath.get().substring(
                    LockPath.length() + 1));
            beforePath.set(LockPath + "/" + children.get(curIndex - 1));
        }
        return false;

    }

    @Override
    public void lock() {
        if (!tryLock()) {
            // 阻塞等待
            waitForLock();
            // 再次尝试加锁
            lock();
        }

    }

    private void waitForLock() {
        // 怎么让自己阻塞
        final CountDownLatch cdl = new CountDownLatch(1);
        // 注册watch,好通知自己什么时候被唤醒
        IZkDataListener listener = new IZkDataListener() {

            @Override
            public void handleDataDeleted(String dataPath) throws Exception {
                System.out.println("----监听到节点被删除..");
                cdl.countDown();

            }

            @Override
            public void handleDataChange(String dataPath, Object data)
                    throws Exception {
                // TODO Auto-generated method stub
                System.out.println("----监听到数据变为：" + data);
            }
        };
        // 注册该事件
        client.subscribeDataChanges(this.beforePath.get(), listener);
        // 这里得判断节点是否存在，否则会永久阻塞
        if (this.client.exists(this.beforePath.get())) {
            try {
                cdl.await();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        try {
            cdl.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        client.unsubscribeDataChanges(this.beforePath.get(), listener);
    }

    @Override
    public void unlock() {
        // 删除节点
        // this.client.deleteRecursive(arg0)表示递归删除
        this.client.delete(this.currentPath.get());

    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        // TODO Auto-generated method stub

    }

    @Override
    public boolean tryLock(long time, TimeUnit unit)
            throws InterruptedException {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public Condition newCondition() {
        // TODO Auto-generated method stub
        return null;
    }

}

　　调用：

public class OrderServiceImpl implements OrderService{
    //定义为静态变量，保证订单号唯一
    private static OrderCodeGenerator ocg=new OrderCodeGenerator();
    //使用lock一定设置为静态变量，保证每个线程竞争的是同一把锁
    private static Lock lock=new ZKDistributeImproveLock("/QQQs");
    //创建订单接口
    @Override
    public void createOrder() {
        // TODO Auto-generated method stub
        String orderCode=null;
        try{//防止出现异常后锁不能释放，所以加try/catch
        lock.lock();
        orderCode=ocg.getOrderCode();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
        //记得释放锁
        lock.unlock();
        }
        System.out.println(Thread.currentThread().getName()+"========"+orderCode);
    }
}

打印结果如下：

log4j:WARN No appenders could be found for logger (org.I0Itec.zkclient.ZkConnection).
log4j:WARN No appenders could be found for logger (org.I0Itec.zkclient.ZkEventThread).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
Thread-4========2018-06-07-10-53-36-1
----监听到节点被删除..
Thread-9========2018-06-07-10-53-36-2
----监听到节点被删除..
Thread-0========2018-06-07-10-53-36-3
----监听到节点被删除..
Thread-1========2018-06-07-10-53-36-4
----监听到节点被删除..
Thread-6========2018-06-07-10-53-36-5
----监听到节点被删除..
Thread-7========2018-06-07-10-53-36-6
----监听到节点被删除..
Thread-5========2018-06-07-10-53-36-7
----监听到节点被删除..
Thread-2========2018-06-07-10-53-36-8
----监听到节点被删除..
Thread-3========2018-06-07-10-53-36-9
----监听到节点被删除..
Thread-8========2018-06-07-10-53-37-10