Zookeeper简述

提到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
 - ls -l
 - ls /
 - delquota -n /testquota
 - ls /
 - listquota /testquota
 - 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表示当前他没有子节点)

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

-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