Bootstrap

【笔记】通过zookeeper实现分布式锁；附上zk的安装教程

参考文档
安装教程

什么是分布式锁

分布式锁呢，就是在分布式系统中，控制不同系统服务访问以及操作相同资源的方式，实现方式有很多种，比如zk以及redis或者是数据库

这里记录的是使用zookeeper 实现分布式锁的方法；

zookeeper实现分布式锁的原理

Zookeeper 是基于临时顺序节点以及 Watcher 监听器机制实现分布式锁的。

【1】ZooKeeper 的每一个节点都是一个天然的顺序发号器。

在每一个节点下面创建临时顺序节点（EPHEMERAL_SEQUENTIAL）类型，新的子节点后面会加上一个次序编号，而这个生成的次序编号是上一个生成的次序编号加一。

例如:
有一个用于发号的节点 “/test/lock” 为父节点，可以在这个父节点下面创建相同前缀的临时顺序子节点，假定相同的前缀为 “/test/lock/seq-”。第一个创建的子节点基本上应该为 /test/lock/seq-0000000001，
下一个节点则为 /test/lock/seq-0000000002，
依次类推。

在这里插入图片描述

【2】ZooKeeper 节点的递增有序性可以确保锁的公平。

一个 ZooKeeper 分布式锁，首先需要创建一个父节点，尽量是持久节点（PERSISTENT 类型），然后每个要获得锁的线程都在这个节点下创建一个临时顺序节点，该节点是按照创建的次序依次递增的。

为了确保公平，可以简单的规定：编号最小的那个节点表示获得了锁。所以，每个线程在尝试占用锁之前，首先判断自己是序号是不是当前最小，如果是则获取锁。
先到先得嘛

【3】ZooKeeper 的节点监听机制，可以保障占有锁的传递有序而且高效

1.每个线程抢占锁之前，先尝试创建自己的 ZNode。
2.同样，释放锁的时候需要删除创建的 Znode。
3.创建成功后，如果不是序号最小的节点，就处于等待通知的状态。
4.每一个等待通知的 Znode 节点，需要监视（watch）序号在自己前面的那个 Znode.
5.以获取其删除事件。只要上一个节点被删除了，就进行再一次判断，看看自己是不是序号最小的那个节点，如果是，自己就获得锁。就这样不断地通知后一个 ZNode 节点。

另外，ZooKeeper 的内部优越的机制，能保证由于网络异常或者其他原因，集群中占用锁的客户端失联时锁能够被有效释放。
机制呢，就是临时顺序节点。一旦占用 Znode 锁的客户端与 ZooKeeper 集群服务器失去联系，这个临时 Znode 也将自动删除。排在它后面的那个节点，也能收到删除事件，从而获得锁。
也正是这个原因，zk 中不需要像 redis 那样考虑锁可能出现的无法释放的问题了，因为当客户端挂了，节点也挂了，锁也释放了。

【4】ZooKeeper 的节点监听机制，能避免羊群效应。

ZooKeeper 这种首尾相接、后面监听前面的方式，可以避免羊群效应。
所谓羊群效应就是一个节点挂掉，所有节点都去监听，然后做出反应，这样会给服务器带来巨大压力。
有了临时顺序节点以及节点监听机制，当一个节点挂掉，只有它后面的那一个节点才做出反应。

具体流程

  1. 一把分布式锁通常使用一个 Znode 节点表示；如果锁对应的 Znode 节点不存在，首先创建 Znode 节点。这里假设为 /test/lock，代表了一把需要创建的分布式锁。
  2. 抢占锁的所有客户端，使用这把锁的 Znode 节点的子节点列表来表示；
    如果某个客户端需要占用锁，则在 /test/lock 下创建一个临时顺序的子节点。
    比如，如果子节点的前缀为 /test/lock/saveUser-则第一次抢锁对应的子节点为 /test/lock/saveUser-000000001，第二次抢锁对应的子节点为 /test/lock/saveUser-000000002，以此类推。
  3. 当客户端创建子节点后，需要进行判断：
    自己创建的子节点，是否为当前子节点列表中序号最小的子节点。
    如果是，则加锁成功；如果不是，则监听前一个 Znode 子节点变更消息，等待前一个节点释放锁。
  4. 一旦队列中的后面的节点，获得前一个子节点变更通知，则开始进行判断，判断自己是否为当前子节点列表中序号最小的子节点，如果是，则认为加锁成功；如果不是，则持续监听，一直到获得锁。（刚才已经加过锁了，但是还不是执行的时候,现在前一个客户端释放锁了，那就轮到洒家上场了！）
  5. 获取锁后，开始处理业务流程。完成业务流程后，删除自己的对应的子节点，完成释放锁的工作，以方面后继节点能捕获到节点变更通知，获得分布式锁

代码的实现

Curator 是Netflix公司开源的一套 ZooKeeper Java客户端框架，相比于 Zookeeper 自带的客户端 zookeeper 来说，Curator 的封装更加完善，各种 API 都可以比较方便地使用。

这里使用 Curator 作为 Zookeeper 的客户端实现。需要先导入依赖：

<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>5.2.1</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>5.2.1</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-client</artifactId>
    <version>5.2.1</version>
</dependency>

Lock接口

public interface Lock {

    boolean lock() throws Exception;

    boolean unlock() throws Exception;

}

Lock实现

相较于参考资料的demo增加了获取锁失败以后删除刚才在上面添加的节点；
失败以后不删除的情况下：
优点：这个锁可以被这个线程二次调用
缺点：可能会造成无效节点的堆积，当这个线程再次获取锁的时候如果从新获取了节点，就不会去使用原来的锁;
需要搭配重试机制使用，如果不重试，用户第二次请求如果不是这个线程执行，将会使用新的节点
删除
有点：不会造成锁的堆积，既然都等待超时了，直接响应超时即可
缺点：不可以重入

public class ZkLock implements Lock{

    private String zkPath;  //分布式锁节点，如"/test/lock"
    private String lockPrefix;  //子节点前缀，如"/test/lock/seq-"
    private long waitTime;  //超时等待
    CuratorFramework zkClient;  //ZK客户端
    private Thread thread;  //当前线程
    private String lockPath;  //当前加锁节点
    private String waitPath;  //前一个等待节点
    final AtomicInteger lockCount = new AtomicInteger(0);  //重入计数器

    // 设置锁构造器
    public ZkLock(String zkPath) throws Exception {
        this.zkPath = zkPath;
        this.lockPrefix = zkPath + "/seq-";
        this.waitTime = 0L;
        this.zkClient = ZkClientFactory.getClient();
        try {
            // 检查锁的主节点,如果不存在这个节点就加锁,否则跳过
            if (zkClient.checkExists().forPath(zkPath) == null) {
                zkClient.create().creatingParentsIfNeeded().forPath(zkPath);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 设置锁构造器,含超时时间
    public ZkLock(String zkPath, long waitTime) {
        this.zkPath = zkPath;
        this.lockPrefix = zkPath + "/seq-";
        this.waitTime = waitTime;
        this.zkClient = ZkClientFactory.getClient();
        try {
            if (zkClient.checkExists().forPath(zkPath) == null) {
                zkClient.create().creatingParentsIfNeeded().forPath(zkPath);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Override
    public boolean lock() throws Exception {
        //可重入
        synchronized (this) {
            // 如果是第一次进入,设置thread = 当前线程,并且进入次数+1
            if (lockCount.get() == 0) {
                thread = Thread.currentThread();
                lockCount.incrementAndGet();
            } else {
                // 如果不是第一次进入,看看锁是不是当前线程的,如果锁不是当前线程的返回错误
                if (!thread.equals(Thread.currentThread())) {
                    return false;
                }
                // 不是第一次进入，锁是当前用户的，则重入次数+1，返回获取锁成功
                lockCount.incrementAndGet();
                return true;
            }
        }
        // 是第一次进入，上面设置完参数以后，尝试获取锁
        return tryLock();
    }

    @Override
    public boolean unlock() throws Exception {
        // 释放锁,如果当前记录的锁不是当前线程的，返回false释放失败
        if (!thread.equals(Thread.currentThread())) {
            return false;
        }
        //
        int newLockCount = lockCount.decrementAndGet();
        if (newLockCount < 0) {
            throw new Exception("解锁异常");
        } else if (newLockCount > 0) {
            return true;
        } else {
            try {
                if (zkClient.checkExists().forPath(lockPath) != null) {
                    zkClient.delete().forPath(lockPath);
                }
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
            return true;
        }
    }

    /**
     * 尝试获取锁
     */
    private boolean tryLock() throws Exception {
        List<String> nodeInt = zkClient.getChildren().forPath(zkPath);
        // 使用传入模式的方式创建,这里使用EPHEMERAL_SEQUENTIAL可以在客户端断开的时候释放锁
        lockPath = zkClient.create().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath(lockPrefix);
        // 获取子节点,传入主锁查询所有子节点列表
        List<String> childList = zkClient.getChildren().forPath(zkPath);
        // 如果列表里只有一个刚才加入的节点,直接获取锁成功
        if (childList.size() == 1) {
            return true;
        } else {
            // 将节点排序
            Collections.sort(childList);
            // 取出获取到的锁路径，截取节点名称
            String curNode = lockPath.substring(zkPath.length() + 1);
            // 将子节点列表排序，看看第一个(min)是不是自己,(查看索引位置-1为当前锁不在子节点中,0为第一)
            int index = childList.indexOf(curNode);// 返回匹配到的节点
            if (index < 0) {
                throw new Exception("加锁异常");
            } else if (index == 0) {
                //第一个节点，加锁成功
                return true;
            } else {
                // 不是第一个就监听前一个节点
                waitPath = zkPath + "/" + childList.get(index - 1); // 父节点+当前节点前一个节点的名称获得完整节点名称进行监听

                final CountDownLatch waitLatch = new CountDownLatch(1);
                // 定义监听流程
                Watcher w = new Watcher() {
                    @Override
                    public void process(WatchedEvent watchedEvent) {
                        // 监听节点的所有事件,如果事件是删除并且是本节点监听的事件,则结束监听继续下一步
                        if (watchedEvent.getType() == Event.EventType.NodeDeleted &&
                                watchedEvent.getPath().equals(waitPath)) {
                            System.out.println("监听到节点删除事件:" + watchedEvent);
                            waitLatch.countDown();  // 结束监听
                        }
                    }
                };
                // 执行监听,客户端.使用监视器.指定监听节点
                zkClient.getData().usingWatcher(w).forPath(waitPath);
                // 监听到了节点删除事件,如果等待时间等于0，
                if (waitTime == 0L) {
                    waitLatch.await();
                    return true;
                } else {
                    boolean await = waitLatch.await(waitTime, TimeUnit.SECONDS);
                    if (!await){
                        // 如果等待超时,删除刚才添加的节点返回失败
                        System.out.println("等待超时,开始释放刚才添加的节点"+Thread.currentThread().getName());
                        unlock();
                    }
                    return await;
                }
            }
        }
    }
}

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
Spring注解-Spring-boot-SpingAOP & Spring事务
C语言 7 VS实用调试技巧
java 工厂类
rpm的制作 spec文件写法
SpringBoot+Vue停车场管理系统的设计与实现(论文+源码)_kaic
什么是JSP？JSP有哪些常用脚本？代码？
【SQL】什么是 InnoDB 的回表
我在Vscode学Java泛型（泛型设计、擦除、通配符）
2022年面试，整理全网初、中、高级常见 Java 面试题
SDE in diffusion models
;