[zk: localhost:2181(CONNECTED) 10] get /test
jay-xu 节点数据
cZxid = 0x2c9e 节点创建时的事务id
ctime = Thu Apr 11 10:03:57 CST 2019 节点创建时间
mZxid = 0x2c9f 节点修改时的事务id
mtime = Thu Apr 11 10:04:14 CST 2019 节点数据修改时间
pZxid = 0x2c9e 与该节点的子节点（或该节点）的最近一次 创建 / 删除 的时间戳对应。只与 本节点 / 该节点的子节点 有关；与孙子节点无关。
cversion = 0 子节点变更的版本
dataVersion = 1 数据版本
aclVersion = 0 ACL版本
ephemeralOwner = 0x0  值为0，表示该节点是持久节点；不为0时，表明这个节点是临时节点，值为会话id(sessionid)
dataLength = 6 数据长度
numChildren = 0 子节点个数

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.recipes.cache.PathChildrenCache;
import org.apache.curator.framework.recipes.cache.PathChildrenCacheEvent;
import org.apache.curator.framework.recipes.cache.PathChildrenCacheListener;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.ZooDefs;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.CountDownLatch;

// 分布式锁，创建节点成功，表示获得锁
public class DistributedLock {

    private static final Logger LOGGER = LoggerFactory.getLogger(DistributedLock.class);

    private CuratorFramework client;

    /** 未获取分布式锁的线程等待 */
    private static CountDownLatch zkLockLatch = new CountDownLatch(1);

    private static final String IMOOC_LOCK_PROJECT = "imooc-locks";

    private static final String DISTRIBUTED_LOCK = "distributed_lock";

    // init
    public DistributedLock(CuratorFramework client) {
        this.client = client;
        // 使用命名空间
        this.client.usingNamespace("ZKlokcs-Namespace");
        try {
            if (this.client.checkExists().forPath("/" + IMOOC_LOCK_PROJECT) == null) {
                client.create()
                        .creatingParentsIfNeeded()
                        .withMode(CreateMode.PERSISTENT)
                        .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
                        .forPath("/" + IMOOC_LOCK_PROJECT);
            }
            // 监听分布式锁节点的删除事件
            addWatcherToLock("/" + IMOOC_LOCK_PROJECT);
        } catch (Exception e) {
            LOGGER.warn("客户端连接ZK服务失败，请重连...");
        }
    }

    // 增加分布式锁节点监听，用于唤醒等待线程
    private void addWatcherToLock(String path) throws Exception {
        final PathChildrenCache pathChildrenCache = new PathChildrenCache(client, path, true);
        pathChildrenCache.start(PathChildrenCache.StartMode.POST_INITIALIZED_EVENT);

        pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
            @Override
            public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) throws Exception {
                // 节点删除，即释放分布式锁
                if (event.getType() == PathChildrenCacheEvent.Type.CHILD_REMOVED) {
                    String path = event.getData().getPath();
                    LOGGER.info("上一个会话已经释放分布式锁或者会话已断开，节点路径为" + path);
                    if (path.contains(DISTRIBUTED_LOCK)) {
                        LOGGER.info("释放计数器，让其他等待线程来获取分布式锁...");
                        zkLockLatch.countDown();
                    }
                }
            }
        });
    }

    // 获取分布式锁
    public void getLock() {
        // 循环尝试
        while (true) {
            try {
                client.create()
                        .creatingParentsIfNeeded()
                        // 临时节点，防止客户端会话断开未释放分布式锁的情况
                        .withMode(CreateMode.EPHEMERAL)
                        .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
                        .forPath("/" + IMOOC_LOCK_PROJECT + "/" + DISTRIBUTED_LOCK);
                LOGGER.info(Thread.currentThread().getName() + " 获取分布式锁成功");
                // 获取锁成功，就退出循环
                return;
            } catch (Exception e) {
                // 节点已存在，表示已经有线程获取锁
                LOGGER.info(Thread.currentThread().getName() + " 获取分布式锁失败");
                try {
                    if (zkLockLatch.getCount() <= 0) {
                        zkLockLatch = new CountDownLatch(1);
                    }
                    // 阻塞等待获取锁
                    zkLockLatch.await();
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

    // 释放分布式锁
    public boolean releaseLock() {
        try {
            if (client.checkExists().forPath("/" + IMOOC_LOCK_PROJECT + "/" + DISTRIBUTED_LOCK) != null) {
                client.delete().forPath("/" + IMOOC_LOCK_PROJECT + "/" + DISTRIBUTED_LOCK);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        LOGGER.info(Thread.currentThread().getName() + " 分布式锁释放完毕");
        return true;
    }

}

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 分布式锁测试
 *
 * @author xuanjian
 */
public class DistributedLockTest {

    private static final ExecutorService EXECUTOR_SERVICE = Executors.newFixedThreadPool(5, new ThreadFactory() {
        private AtomicLong counter = new AtomicLong(0);

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setName("dslock-test-" + counter.incrementAndGet());
            return t;
        }
    });
    private static Random random = new Random();
    private static DistributedLock distributedLock;

    static {
        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString("localhost:2181")
                .sessionTimeoutMs(50000)
                .connectionTimeoutMs(50000)
                .retryPolicy(new ExponentialBackoffRetry(1000, 5))
                .build();
        client.start();

        distributedLock = new DistributedLock(client);
    }

    public static void main(String[] args) {
        // 模拟分布式场景，多个进程争用分布式锁
        int i = 0;
        while (i < 5) {
            EXECUTOR_SERVICE.submit(() -> {
                distributedLock.getLock();
                try {
                    // 操作
                    TimeUnit.SECONDS.sleep(random.nextInt(5) + 1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    distributedLock.releaseLock();
                }
            });
            i++;
        }

        EXECUTOR_SERVICE.shutdown();
        System.out.println("all done!!!");
    }

}