zookeeper分布式锁实现

zookepeer分布式锁是通过zookeeper临时有序节点特性实现的

zookeeper实现分布式锁的算法流程

假设锁空间的根节点为/lock：

1. 客户端连接zookeeper，并在/lock下创建临时的且有序的子节点，第一个客户端对应的子节点为/lock/lock-0000000000，第二个为/lock/lock-0000000001，以此类推。
2. 客户端获取/lock下的子节点列表，判断自己创建的子节点是否为当前子节点列表中序号最小的子节点，如果是则认为获得锁，否则监听刚好在自己之前一位的子节点删除消息，获得子节点变更通知后重复此步骤直至获得锁；
3. 执行业务代码；
4. 完成业务流程后，删除对应的子节点释放锁。

步骤1中创建的临时节点能够保证在故障的情况下锁也能被释放，考虑这么个场景：假如客户端a当前创建的子节点为序号最小的节点，获得锁之后客户端所在机器宕机了，客户端没有主动删除子节点；如果创建的是永久的节点，那么这个锁永远不会释放，导致死锁；由于创建的是临时节点，客户端宕机后，过了一定时间zookeeper没有收到客户端的心跳包判断会话失效，将临时节点删除从而释放锁。

另外细心的朋友可能会想到，在步骤2中获取子节点列表与设置监听这两步操作的原子性问题，考虑这么个场景：客户端a对应子节点为/lock/lock-0000000000，客户端b对应子节点为/lock/lock-0000000001，客户端b获取子节点列表时发现自己不是序号最小的，但是在设置监听器前客户端a完成业务流程删除了子节点/lock/lock-0000000000，客户端b设置的监听器岂不是丢失了这个事件从而导致永远等待了？这个问题不存在的。因为zookeeper提供的API中设置监听器的操作与读操作是原子执行的，也就是说在读子节点列表时同时设置监听器，保证不会丢失事件。

最后，对于这个算法有个极大的优化点：假如当前有1000个节点在等待锁，如果获得锁的客户端释放锁时，这1000个客户端都会被唤醒，这种情况称为“羊群效应”；在这种羊群效应中，zookeeper需要通知1000个客户端，这会阻塞其他的操作，最好的情况应该只唤醒新的最小节点对应的客户端。应该怎么做呢？在设置事件监听时，每个客户端应该对刚好在它之前的子节点设置事件监听，例如子节点列表为/lock/lock-0000000000、/lock/lock-0000000001、/lock/lock-0000000002，序号为1的客户端监听序号为0的子节点删除消息，序号为2的监听序号为1的子节点删除消息。

pom.xml

		
			org.apache.curator
			curator-framework
			2.11.1
		
		
			org.apache.curator
			curator-recipes
			2.11.1
		

java:

package com.example.demo.zookeeper;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;

/**
 * 分布式锁
 * 通过zk 临时有序、watcher机制实现
 *
 * @author zhangming
 * @version 1.0
 * @date 2019-08-21 20:55
 */
public class LockDemo {
    private static final String ZOOKEEER_URL = "127.0.0.1:2181";
    //超时时间 毫秒
    private static final int TIME_OUT = 5000;
    public static void main(String[] args) {
        //ExponentialBackoffRetry重试 1000表示1000毫秒重试，最大重试3次
        CuratorFramework curatorFramework = CuratorFrameworkFactory.builder().connectString(ZOOKEEER_URL).sessionTimeoutMs(TIME_OUT)
                .retryPolicy(new ExponentialBackoffRetry(1000,3)).build();
        //启动
        curatorFramework.start();

        final InterProcessMutex lock = new InterProcessMutex(curatorFramework,"/lock");
        /**
         * 具体步骤：
         * 1、首先在lock节点下创建10个临时有序节点
         * 2、lock.acquire()获得锁，前提是lock.release()要释放锁
         * 3、lock.release()删除对应的临时有序节点，后面节点将存放最小值。
         *
         */

        for (int i = 0; i<10;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"--尝试竞争锁");
                try {
                    //获取锁  会阻塞
                    lock.acquire();
                    System.out.println(Thread.currentThread().getName()+"--获得锁");
                } catch (Exception e) {
                    e.printStackTrace();
                }
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    try {
                        //释放锁
                        lock.release();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

    }
}