9.Apache-Zookeeper 应用场景-分布式锁

1. 分布式锁介绍

在开发多并发程序时锁是重要的保证数据一致的手段，但是jvm的锁只能在一个进程中使用，分布式下多个进程，多个服务器间 jvm锁已经无法起作用了，所以我们要使用分布式锁。

1.1. 公平锁

每个线程都会执行的锁为公平锁，一般来说是使用一个队列，线程轮流去获取锁，能保证每个线程都有机会获取到锁

1.2. 非公平锁

非公平锁无法保证所有的线程一定能获取到锁，可能每次获取锁某个线程因为网络或其他问题每次都获取不到锁，会一致等待获取锁。

2. zk实现分布式锁

由于获取不到锁就要等待，触发watch就要结束等待，所以，我们这儿使用了CountDownLatch

CountDownLatch是一个非常实用的多线程控制工具类。常用的就下面几个方法：

CountDownLatch(int count) //实例化一个倒计数器，count指定计数个数
countDown() // 计数减一
await() //等待，当计数减到0时，所在线程并行执行

2.1. zk实现非公平锁原理

public class UnfairLock {
    private static final String LOCK_NODE_PARETN="/sumanItLock";
    private ZooKeeper zk;
    private byte[] BUF = new byte[0];


    public UnfairLock(ZooKeeper zk) {
        this.zk = zk;
        try {
            init();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void init() throws Exception{
        zk.create(LOCK_NODE_PARETN,BUF, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    }

    public boolean tryToLock(String key){
        try {
            zk.create(LOCK_NODE_PARETN+"/"+key,BUF, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);

            return true;
        } catch (Exception e) {

            CountDownLatch countDownLatch = new CountDownLatch(1);
            try {
                zk.exists(LOCK_NODE_PARETN + "/" + key, event -> {
                    countDownLatch.countDown();
                });
                countDownLatch.await();
                return tryToLock(key);//锁被释放，再次尝试获取
            }catch (Exception e1){

            }

        }
        return false;
    }

    public boolean  unLock(String key){
        try {
            zk.delete(LOCK_NODE_PARETN+"/"+key,-1);
            return true;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
        return false;
    }

}

2.2. zk实现公平锁原理

public class FairLock {
    private static final String LOCK_NODE_PARETN="/sumanItLock";
    private ZooKeeper zk;
    private byte[] BUF = new byte[0];
    private static final ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<>();

    public FairLock(ZooKeeper zk) {
        this.zk = zk;
        try {
            init();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void init() throws Exception{
        zk.create(LOCK_NODE_PARETN,BUF, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    }

    public boolean tryToLock(String key){

        try {
            System.out.println("开始创建节点");
            String currentNode =  zk.create(LOCK_NODE_PARETN+"/"+key,BUF, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
            System.out.println("创建节点成功"+currentNode);
            THREAD_LOCAL.set(currentNode);
            List<String> children = zk.getChildren(LOCK_NODE_PARETN, false);
            children = children.stream().filter(item -> item.startsWith(key)).sorted().collect(Collectors.toList());
            System.out.println(children.get(0)+"\t"+currentNode);
            if(currentNode.endsWith(children.get(0))){//如果自己是第一个 获取到锁
                return true;
            }
            CountDownLatch countDownLatch = new CountDownLatch(1);
            for (int i = 1; i < children.size() ; i++) {
                if(currentNode.endsWith(children.get(i))){
                    zk.exists(LOCK_NODE_PARETN+"/"+children.get(i-1),watchedEvent -> {
                        countDownLatch.countDown();
                    });
                    break;
                }
            }
            countDownLatch.await();

            return true;
        } catch (Exception e) {
             e.printStackTrace();
        }
        return false;
    }

    public boolean  unLock(){
        try {
            zk.delete(THREAD_LOCAL.get(),-1);
            return true;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
        return false;
    }
}

3. 不足

上面两个例子都是介绍原理而做的，无法应用到生产环境中，因为容错太少，容易产生死锁。比如程序没有死亡但是业务死掉，就会导致一值不解锁，死锁产生。如果想应用到环境，可以在网上搜索更成熟的写法。无法重入，可能会导致死锁。