@Test
    public void getChildRen() throws KeeperException, InterruptedException {
        //true:使用init中创建的监听器. 每次出现变化,将重新调用监听器中的 方法.  也可以自定一个监听器.
        //监听某个路径的节点变化情况
        List <String> children = zkClient.getChildren("/", true);
        for (String child : children) {
            System.out.println(child);
        }
        //延时 让其一直监听
        Thread.sleep(Long.MAX_VALUE);
    }

@Test
    public void exist() throws KeeperException, InterruptedException {
        Stat stat = zkClient.exists("/atguigu", false);
        System.out.println(stat==null ? "not exist ":"exist");
    }

[zk: localhost:2181(CONNECTED) 1] create -e -s
/servers/hadoop102 "hadoop102"
[zk: localhost:2181(CONNECTED) 2] create -e -s
/servers/hadoop103 "hadoop103"

/**
 * CountDownLatch典型用法：1、某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为new CountDownLatch(n)，
 * 每当一个任务线程执行完毕，就将计数器减1 .countdownLatch.countDown()，当计数器的值变为0时，在CountDownLatch上await()的线程就会被唤醒。
 * 一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行
 *
 */
public class DistributedLock {
    private final String connectString = "hadoop102:2181,hadoop103:2181,hadoop104:2181";
    private final int sessionTimeout = 2000;
    private final ZooKeeper zk;
    //CountDownLatch 用来等待 连接成功
    private CountDownLatch connectLatch = new CountDownLatch(1);
    private CountDownLatch waitLatch = new CountDownLatch(1);
    private String currentMode;
    private String waitPath;
    //分布式锁的初始化
    public DistributedLock() throws IOException, InterruptedException, KeeperException {
        //获取连接
         zk = new ZooKeeper(connectString, sessionTimeout, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                //connection 如果连接上zk 可以释放
                // 如果监听的状态 是 连接上的状态,则释放connectLatch,继续往下执行.
                if(event.getState()==Event.KeeperState.SyncConnected){
                    connectLatch.countDown();
                }
                //waitLatch 需要释放
                //如果监听到了 监听路径的节点删除操作. 并且该操作的路径是当前节点的上一个节点,则释放waitLatch
                if(event.getType()==Event.EventType.NodeDeleted && event.getPath().equals(waitPath)){
                    waitLatch.countDown();
                }
            }
        });
         //等待zk正常连接后,往下走程序
        connectLatch.await();
        //判断根节点 /locks 是否存在
        Stat stat = zk.exists("/locks", false);
        if(stat==null){
            //创建下一个根节点
            zk.create("/locks", "locks".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }
    //对zk加锁
    public void zklock() throws KeeperException, InterruptedException {
        //创建对应的临时带序号节点(目的是对资源进行操作.)
        currentMode = zk.create("/locks/" + "seq-", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        //判断创建的节点是否是最小的序号节点,如果是获取到锁; 如果不是,监听序号前一个节点.
        List <String> children = zk.getChildren("/locks", false);
        //如果children只有一个值, 那就直接获取锁;  如果有多个节点,则需要判断谁最小.
        if(children.size()==1){
            return;
        }else{
            Collections.sort(children);
            //获取节点名称 seq-000000
            /**
             * substring(int biginIndex)
             * substring(int biginIndex,int endIndex)
             */
            String thisNode = currentMode.substring("/locks/".length());
            //通过seq-000000获取该节点在children集合的位置
            int index = children.indexOf(thisNode);
            //判断
            if(index==-1){
                System.out.println("数据异常...");
            }else if(index == 0){
                //如果当前的是序号最小的节点,则直接获取锁
                return;
            }else{//当前的节点并不是序号最小的
                //需要监听它前一个结点的变化
                waitPath = "/locks/" + children.get(index - 1);
                zk.getData(waitPath,true,null);
                //等待前一个节点操作完成,监听结束,本节点再获取锁.
                waitLatch.await();
                return;
            }
        }
    }
    //解锁
    public void unZkLock() throws KeeperException, InterruptedException {
        // 操作处理完毕要解锁----删除当前节点.
        zk.delete(this.currentMode,-1);
    }
}

public class DistributedLockTest {
    public static void main(String[] args) throws InterruptedException, IOException, KeeperException {
        final DistributedLock lock1 = new DistributedLock();
        final DistributedLock lock2 = new DistributedLock();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock1.zklock();
                    System.out.println("线程1启动, 获取到锁");
                    System.out.println("线程1使用资源中...");
                    Thread.sleep(5*1000);
                    lock1.unZkLock();
                    System.out.println("线程1使用资源完毕,释放锁");
                } catch (KeeperException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock2.zklock();
                    System.out.println("线程2启动, 获取到锁");
                    System.out.println("线程2使用资源中...");
                    Thread.sleep(5*1000);
                    lock2.unZkLock();
                    System.out.println("线程2使用资源完毕,释放锁");
                } catch (KeeperException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

<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>