zk基于临时节点的分布式锁

package com.yucong.zkClient;

import java.util.Random;
import java.util.concurrent.CountDownLatch;

import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;

/**
 * <li>基于临时节点的分布式锁</li>
 */
public class EphemeralLock {

    private static final String PATH = "/EphemeralLock";
    private ZkClient zkClient = new ZkClient("127.0.0.1:2181");// 在这里每一个线程都有自己的zkClient，用完需要关闭
    private CountDownLatch latch = null;

    // 获得锁
    public void getLock() {
        if (tryLock()) {
            System.out.println(Thread.currentThread().getName() + ": 获得锁");
        } else {
            // 等待临时节点被删除
            waitLock();
            // 继续获取锁
            getLock();
        }
    }

    // 释放锁
    public void unLock() {
        if (zkClient != null) {
            System.out.println(Thread.currentThread().getName() + ": 释放锁");
            zkClient.delete(PATH);
            zkClient.close();
        }
    }

    private boolean tryLock() {
        try {
            zkClient.createEphemeral(PATH);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    private void waitLock() {
        IZkDataListener listener = new IZkDataListener() {
            @Override
            public void handleDataDeleted(String dataPath) throws Exception {
                if (latch != null) {
                    latch.countDown();
                }
            }
            @Override
            public void handleDataChange(String dataPath, Object data) throws Exception {}
        };

        // 注册事件
        zkClient.subscribeDataChanges(PATH, listener);

        // 如果节点存，阻塞线程直到PATH被删除，触发handleDataDeleted事件
        if (zkClient.exists(PATH)) {
            latch = new CountDownLatch(1);
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 删除监听
        zkClient.unsubscribeDataChanges(PATH, listener);
    }

    public static void main(String[] args) throws Exception {
        int conut = 10;
        CountDownLatch countDownLatch = new CountDownLatch(conut);
        for (int i = 0; i < conut; i++) {
            new Thread(new Person(countDownLatch)).start();
        }
        countDownLatch.await(); // 打开所有线程
    }
}


/**
 * <li>模拟多用户</li>
 */
class Person implements Runnable {
    private EphemeralLock lock = new EphemeralLock();
    private CountDownLatch countDownLatch = null;

    public Person(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        try {
            countDownLatch.countDown(); // 阻塞所有线程
            lock.getLock();
            int i = new Random().nextInt(3) + 1;
            Thread.sleep(i * 1000);
            System.out.println(Thread.currentThread().getName() + ": 开始睡眠" + i + "s");
        } catch (Exception e) {
            //
        } finally {
            lock.unLock();
        }
    }
}