Curator实现zookeeper分布式锁

 maven依赖

        
            org.apache.curator
            curator-recipes
            4.0.0
        

import lombok.SneakyThrows;
import org.apache.curator.RetryPolicy;
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;
import org.apache.zookeeper.data.Stat;

import java.util.concurrent.TimeUnit;

public class ZkLock {

    public static void main(String[] args) throws Exception {

        final String connectString = "localhost:2181";

        // 重试策略，初始化每次重试之间需要等待的时间，基准等待时间为1秒。
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);

        // 使用默认的会话时间（60秒）和连接超时时间（15秒）来创建 Zookeeper 客户端
       Curatorframework client = CuratorframeworkFactory.builder().
                connectString(connectString).
                connectionTimeoutMs(15 * 1000).
                sessionTimeoutMs(60 * 100).
                retryPolicy(retryPolicy).
                build();

        // 启动客户端
        client.start();

        final String lockNode = "/lock_node";
        InterProcessMutex lock = new InterProcessMutex(client, lockNode);


        for (int i=0;i<10;i++){
            new Thread(new Runnable() {
                @SneakyThrows
                @Override
                public void run() {
                    try {
                        if (lock.acquire(60, TimeUnit.MINUTES)) {
                            Stat stat = client.checkExists().forPath(lockNode);
                            if (null != stat){
                                Thread.sleep(60000);
                            }
                        }
                    } finally {
                        if (lock.isAcquiredInThisProcess()) {
                            lock.release();
                        }
                    }
                }
            }).start();
        }
    }
}

上述代码由于有10个线程会去争夺 锁资源，会在lock_node节点下创建10个临时顺序节点 

 其大致的原理是，比如有A和B两个线程去争夺锁资源

1、假如A先在lock_node 创建临时目录节点，节点名后缀为 0000；

2、随后B在lock_node 创建临时目录节点，节点名后缀为 0001；

3、此时A和B就要判断 自己是否是lock_node 创建的第一个节点

4、A判断自己是第一个节点，获取锁

5、B判断自己不是第一个节点，则往自己前一个节点0000注册一个 delete 监听事件

6、此时假如A执行完了，把0000节点删了，就会去出发B节点的监听事件，此时B节点就会去检查自己是否是第一个节点，如果是，则获取锁，如果不是，则往上一个节点又继续注册delete监听事件................