分布式专题｜如何使用zookeeper实现分布式锁

在分布式中，避免不了使用分布式锁，在前面的专题中，我们已经说过使用Redis实现分布式锁，这里我将给大家演示如何使用zookeeper实现分布式锁。

首先，给大家介绍下实现的基本思路，这里默认大家已经掌握了分布式锁的基本概念了，如果还没有理解分布式锁是用来干嘛的，可以查阅相关文章了解下：

共享锁(读写锁)：

两种锁都是基于序号节点的特性完成，zookeepr帮我们保证了创建节点的顺序一致性，先创建的，节点序号比后创建的节点序号要小，所以我们可以这么实现：

共享锁实现思路

在这里插入图片描述

如果是写锁：
1. 创建一个序号节点 lock-w-00003
2. 获取锁节点下的所有序号子节点
3. 通过比较节点序号大小，lock-w-00003是最小的序号节点，则表明获取成功
4. 否则如果lock-w-00003不是最小的序号节点，则对lock-w-00003前面的一个节点进行监听，并阻塞当前线程；如果前面一个节点变化了，再进行同样的判断，直至lock-w-00003是最小的子节点，即获取锁成功；
如果是读锁：
1. 创建一个序号节点lock-r-0004
2. 获取锁节点下的所有序号子节点
3. 通过比较序号节点大小。如果在lock-r-00004前面都是读节点，那么就代表获取读锁成功，否则监听lock-r-00004前一个节点，并阻塞当前线程；如果节点发生变化，则进行同样的判断，直到lock-r-00004前面都是读节点，获取lock-r-00004是最小的节点，才代表获取锁成功；

排它锁实现思路

在这里插入图片描述

创建序号节点，lock-0005
获取锁节点下的所有序号子节点
比较发现，lock-0005是最小的子节点，则代表获取排它锁成功；
否则监听lock-0005前面的节点变化，并阻塞当前线程
如果发现到节点变化，则继续执行2-4的操作，直至获取锁；

排它锁实现核心代码及注释

   @Override
    public void lock() {
        if (tryLock()) { //如果获取锁成功，则直接返回
            System.out.println("###成功获取锁###");
        } else {
        // 获取锁失败，监听前面的子节点，阻塞等待
            waitLock();
            // 前面子节点被删除，重新获取锁
            lock();
        }
    }
    @Override
    public void unLock() {
        if(zkClient!=null){
            // 由子类调用，关闭会话，防止回话过多，导致拒绝链接
            zkClient.close();
            System.out.println("###释放所资源###");
        }
    }

public boolean tryLock() {
// 创建临时序号节点
        if (null == currentPath || currentPath.length() <= 0) {
            currentPath = zkClient.createEphemeralSequential(lockPath + "/", "lock");
        }
// 获取所有子节点按照从小到大进行排序
        List<String> children = zkClient.getChildren(lockPath);
        Collections.sort(children);
        // 判断第一个节点是否是自己，如果是自己，则获取锁成功，直接返回
        if (currentPath.equals(lockPath + "/" + children.get(0))) {
            System.out.println("成功获取锁：" + currentPath);
            return true;
        }
        String key = currentPath.substring(lockPath.length() + 1);      
        int location = Collections.binarySearch(children, key);
        // 定位前面一个节点的位置，进行监听
        this.beforePath = lockPath + "/" + children.get(location - 1);
        return false;
    }

// 锁获取失败，会调用此方法
    public void waitLock() {
        IZkDataListener listener = new IZkDataListener() {
            public void handleDataChange(String s, Object o) {
            }

            public void handleDataDeleted(String s) {
                LATCH.countDown();
            }
        };
        // 监听前面一个子节点变化
        zkClient.subscribeDataChanges(this.beforePath, listener);
        // 如果没有子节点，则直接返回，重新获取锁
        if (!zkClient.exists(this.beforePath)) {
            return;
        }
        try {
        // 这里使用JUC中的CountDownLatch 进行阻塞等待
            LATCH.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 被监听的节点发生变化，取消监听，节省资源；
        zkClient.unsubscribeDataChanges(this.beforePath, listener);
    }

// 子类实现的释放锁的方法
   @Override
    public void unLock() {
        System.out.println("成功释放锁"+currentPath);
        zkClient.delete(currentPath);
        // 调用父类方法释放资源
        super.unLock();
    }

代码已经上传到码云 https://gitee.com/yangleliu/code_learning.git

读写锁实现核心代码及注释

读写锁和排它锁代码在实现方式上主要是在tryLock的方式上不同：

写锁

 public boolean tryLock() {
        if (null == currentPath || currentPath.length() <= 0) {
            currentPath = zkClient.createEphemeralSequential(lockPath + "/write", "lock");
        }
        List<String> children = zkClient.getChildren(lockPath);
        // 按照序号节点进行排序
        Collections.sort(children, Comparator.comparingInt(o -> Integer.parseInt(o.replaceAll("[^0-9]*", ""))));
//        System.out.println("当前孩子:"+children.toString());
        // 如果当前节点是第一个，则代表获取写锁成功
        if (currentPath.equals(lockPath + "/" + children.get(0))) {
            System.out.println("成功获取锁：" + currentPath);
            return true;
        }
        String key = currentPath.substring(lockPath.length() + 1);
        
        int location = children.indexOf(key);
        // 获取前面一个序号节点，并监听
        this.beforePath = lockPath + "/" + children.get(location - 1);
        System.out.println("获取写锁失败"+key);
        System.out.println("当前孩子:"+children.toString());
        return false;
    }

读锁

  public boolean tryLock() {
        if (null == currentPath || currentPath.length() <= 0) {
            currentPath = zkClient.createEphemeralSequential(lockPath + "/read", "lock");
            System.out.println(currentPath);
        }
        List<String> children = zkClient.getChildren(lockPath);
        // 按照节点进行排序
        Collections.sort(children, Comparator.comparingInt(o -> Integer.parseInt(o.replaceAll("[^0-9]*", ""))));
        // 如果当前节点处于第一个则获取锁成功
        if (currentPath.equals(lockPath + "/" + children.get(0))) {
//            System.out.println("成功获取锁：" + currentPath);
            return true;
        }
        String key = currentPath.substring(lockPath.length() + 1);
        int location = children.indexOf(key);
        // 遍历当前节点位置前面的所有子节点
        for (int i=0;i<location;i++){
            System.out.println(children.get(i));
            // 如果包含写锁，则直接返回获取锁失败，
            if (children.get(i).contains("write")){
                this.beforePath = lockPath + "/" + children.get(location - 1);
                System.out.println("获取读锁失败：当前孩子"+children.toString());
                return false;
            }
        }
        // 如果前面没有写锁，则代表获取锁成功
        return true;
    }

微信搜一搜【AI码师】关注帅气的我，回复【干货领取】，将会有大量面试资料和架构师必看书籍等你挑选，包括java基础、java并发、微服务、中间件等更多资料等你来取哦。

分布式专题｜还在使用redis实现分布式锁么，来看看zookeepr如何优雅的实现分布式锁(排它锁｜读写锁)