zk分布式锁解决方案

普通版

思路

加锁时，在指定路径创建临时节点（临时节点避免死锁），于是只有一个线程能创建成功；

等待时，其他创建节点失败的线程，会watch指定路径的删除事件，一旦事件触发，说明临时节点被删除，线程可以继续去获取锁；

解锁时，当前线程删除它创建的节点

代码

public class ZookeeperDistrbuteLock  {
    // zk连接地址
    private static final String CONNECTSTRING = "192.168.40.140:2181";
    // 创建zk连接
    protected ZkClient zkClient = new ZkClient(CONNECTSTRING);
    protected static final String PATH = "/lock";
    private CountDownLatch countDownLatch = null;

    @Override
    //尝试获得锁
    public  boolean tryLock() {
        try {
            zkClient.createEphemeral(PATH);
            return true;
        } catch (Exception e) {
            //如果创建失败报出异常
            return false;
        }

    }

    @Override
    public void waitLock() {
        IZkDataListener izkDataListener = new IZkDataListener() {

            public void handleDataDeleted(String path) throws Exception {
                // 唤醒被等待的线程
                if (countDownLatch != null) {
                    countDownLatch.countDown();
                }
            }
            public void handleDataChange(String path, Object data) throws Exception {

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

        //如果节点存
        if (zkClient.exists(PATH)) {
            countDownLatch = new CountDownLatch(1);
            try {
                //等待，一直等到接受到事件通知
                countDownLatch.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        // 删除监听
        zkClient.unsubscribeDataChanges(PATH, izkDataListener);
    }

    public void unLock() {
        //释放锁
        if (zkClient != null) {
            zkClient.delete(PATH);
            zkClient.close();
            System.out.println("释放锁资源...");
        }
    }
}

使用时注意，由于countDownLatch和zkClient（如果共享，那么当一个线程调用close方法后，其他线程再创建节点时会报错）在此处不是共享变量，所以每个线程使用时都需要new ZookeeperDistrbuteLock类的实例

缺点

会引起羊群效应，即解锁后大量等待的线程纷涌而至。

优化版

思路（类似于公平锁）

加锁时，也是在指定路径创建临时节点，但此时是带序号的节点，最终多个线程都能创建节点成功，格式为路径+递增序号。
但是需要从这么多节点中选出第一个，于是对路径进行排序，只有创建了第一个节点的线程，才能返回true；反之，获取它前面一个节点的路径

等待时，创建失败的线程依次watch它前一个节点路径，每个节点都是如此；

解锁时，当前线程删除它创建的节点

代码

public class ZookeeperDistrbuteLock2{
 // zk连接地址
    private static final String CONNECTSTRING = "192.168.40.140:2181";
    // 创建zk连接
    protected ZkClient zkClient = new ZkClient(CONNECTSTRING);
    protected static final String PATH = "/lock2";
    private CountDownLatch countDownLatch = null;

    private String beforePath;//当前请求的节点前一个节点
    private String currentPath;//当前请求的节点

    public ZookeeperDistrbuteLock2() {
        if (!this.zkClient.exists(PATH2)) {
            //如果不先创建，那么创建/lock2/XXXX等临时节点时，会报/lock2节点不存在的错误
            this.zkClient.createPersistent(PATH2);
        }
    }


    @Override
    public boolean  tryLock() {
        //如果currentPath为空则为第一次尝试加锁，第一次加锁赋值currentPath
        if(currentPath == null || currentPath.length()<= 0){
            //创建一个临时顺序节点（此时path2后加了“/”，是为了getChildren方法能获取到子节点）
            currentPath = this.zkClient.createEphemeralSequential(PATH2 + '/',"lock");
            System.out.println(Thread.currentThread().getName() + "————" + currentPath);
        }
        //获取所有临时节点并排序，临时节点名称为自增长的字符串如：0000000400
        List<String> childrens = this.zkClient.getChildren(PATH2);
        Collections.sort(childrens);

        if (currentPath.equals(PATH2 + '/'+childrens.get(0))) {//如果当前节点在所有节点中排名第一则获取锁成功
            return true;
        } else {//如果当前节点在所有节点中排名中不是排名第一，则获取前面的节点名称，并赋值给beforePath
            int wz = Collections.binarySearch(childrens,
                    currentPath.substring(7));
            beforePath = PATH2 + '/'+childrens.get(wz-1);
        }
        return false;

    }

    @Override
    public void waitLock() {
        IZkDataListener listener = new IZkDataListener() {

            public void handleDataDeleted(String dataPath) throws Exception {

                if(countDownLatch!=null){
                    countDownLatch.countDown();
                }
            }

            public void handleDataChange(String dataPath, Object data) throws Exception {

            }
        };
        //给排在前面的的节点增加数据删除的watcher,本质是启动另外一个线程去监听前置节点
        this.zkClient.subscribeDataChanges(beforePath, listener);

        if(this.zkClient.exists(beforePath)){
            countDownLatch=new CountDownLatch(1);
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.zkClient.unsubscribeDataChanges(beforePath, listener);
    }


    public void unLock() {
        //删除当前临时节点
        zkClient.delete(currentPath);
        zkClient.close();
    }
}

优点

后面的节点只会watch前面的节点，当释放锁时，不会引起羊群效应