--- theme: condensed-night-purple --- > 篇幅太长看着也累，尝试分成多个小章节，每天进步一点点。 ## 前情回顾分布式锁系列内容规划如下，本篇是第 2 篇： 1. [《分布式锁上-初探](https://juejin.cn/post/7158275654889734175 "https://juejin.cn/post/7158275654889734175")》 1. [《分布式锁中-基于 Zookeeper 的实现是怎样》](https://juejin.cn/post/7159014085638488072 "https://juejin.cn/post/7159014085638488072")（本篇） 1. [《分布式锁中-基于 etcd 的实现很优雅》](https://juejin.cn/post/7162874884035444766 "https://juejin.cn/post/7162874884035444766") 1. [《分布式锁中-基于 Redis 的实现需避坑 - Jedis 篇》](https://juejin.cn/post/7166131629348356104) 1. 《分布式锁中-基于 Redis 的实现很多样 - Redission 篇》（写作中） 2. 《分布式锁中-基于 MySQL 的实现 - 有得用就好》（写作中） 3. 《分布式锁中-多维度的对比各种分布式锁实现》（写作中） 4. 《分布式锁下-分布式锁客户端的抽象、适配与加固》（写作中） ## ZooKeeper介绍 Zookeeper（后续简称ZK）是一个分布式的，开放源码的分布式应用程序协调服务，通常以集群模式运转，其协调能力可以理解为是基于观察者设计模式来实现的；ZK服务会使用Znode存储使用者的数据，并将这些数据以树形目录的形式来组织管理，支持使用者以观察者的角色指定自己关注哪些节点\数据的变更，当这些变更发生时，ZK会通知其观察者；为满足本篇目标所需，着重介绍以下几个关键特性： - 数据组织：数据节点以树形目录(类似文件系统)组织管理，每一个节点中都会保存数据信息和节点信息。

ZooKeeper's Hierarchical Namespace

- 集群模式：通常是由3、5个基数实例组成集群，当超过半数服务实例正常工作就能对外提供服务，既能避免单点故障，又尽量高可用，每个服务实例都有一个数据备份，以实现数据全局一致

ZooKeeper Service

- 顺序更新：更新请求都会转由leader执行，来自同一客户端的更新将按照发送的顺序被写入到ZK，处理写请求创建Znode时，Znode名称后会被分配一个全局唯一的递增编号，可以通过顺序号推断请求的顺序，利用这个特性可以实现高级协调服务

- 监听机制：给某个节点注册监听器，该节点一旦发生变更（例如更新或者删除），监听者就会收到一个Watch Event，可以感知到节点\数据的变更

- 临时节点：session链接断开临时节点就没了，不能创建子节点（很关键） ZK的分布式锁正是基于以上特性来实现的，简单来说是： - 临时节点：用于支撑异常情况下的锁自动释放能力 - 顺序节点：用于支撑公平锁获取锁和排队等待的能力 - 监听机制：用于支撑抢锁能力 - 集群模式：用于支撑锁服务的高可用 ## 2. 加解锁的流程描述 ![图片](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8d065f419a5045d386b7dd3123f6c57f~tplv-k3u1fbpfcp-zoom-1.image) 1. 创建一个永久节点作为锁节点（/lock2） 1. 试图加锁的客户端在指定锁名称节点（/lock2）下，创建临时顺序子节点 1. 获取锁节点（/lock2）下所有子节点 1. 对所获取的子节点按节点自增序号从小到大排序 1. 判断自己是不是第一个子节点，若是，则获取锁 1. 若不是，则监听比该节点小的那个节点的删除事件（这种只监听前一个节点的方式避免了惊群效应） 1. 若是阻塞申请锁，则申请锁的操作可增加阻塞等待 1. 若监听事件生效（说明前节点释放了，可以尝试去获取锁），则回到第3步重新进行判断，直到获取到锁 1. 解锁时，将第一个子节点删除释放 ## 3. ZK分布式锁的能力可能读者是单篇阅读，这里引入第一篇[《分布式锁上-初探》](https://juejin.cn/post/7158275654889734175)中的一些内容，一个分布式锁应具备这样一些功能特点： - 互斥性：在同一时刻，只有一个客户端能持有锁 - 安全性：避免死锁，如果某个客户端获得锁之后处理时间超过最大约定时间，或者持锁期间发生了故障导致无法主动释放锁，其持有的锁也能够被其他机制正确释放，并保证后续其它客户端也能加锁，整个处理流程继续正常执行 - 可用性：也被称作容错性，分布式锁需要有高可用能力，避免单点故障，当提供锁的服务节点故障（宕机）时不影响服务运行，这里有两种模式：一种是分布式锁服务自身具备集群模式，遇到故障能自动切换恢复工作；另一种是客户端向多个独立的锁服务发起请求，当某个锁服务故障时仍然可以从其他锁服务读取到锁信息(Redlock) - 可重入性：对同一个锁，加锁和解锁必须是同一个线程，即不能把其他线程程持有的锁给释放了 - 高效灵活：加锁、解锁的速度要快；支持阻塞和非阻塞；支持公平锁和非公平锁基于上文的内容，这里简单总结一下ZK的能力矩阵（etcd 的情况请看[《分布式锁中-基于etcd的实现好优雅》](https://juejin.cn/post/7162874884035444766)，Redis 锁的情况会在后续文章中补充）： | 能力 | ZK | etcd | Redis 原生 | Redlock | | ----- | --------------------- | ---------------------------------------- | -------- | ------- | | 互斥 | 是 | 是 | | | | 安全 | 链接异常时，session 丢失自动释放锁 | 基于租约，租约过期后自动释放锁，不用像ZK那样释放链接 | | | | 可用性 | 相对可用性还好 | 好 | | | | 可重入 | 服务端非可重入，本地线程可重入 | 服务端非可重入，本地线程可重入需自研 | | | | 加解锁速度 | 速度不算快 | 速度快，如GRPC 协议优势、服务端性能的优势 | | | | 阻塞非阻塞 | 客户端两种能力都提供 | jetcd-core 中，阻塞非阻塞由 Future#get 的超时控制能力支撑 | | | | 公平非公平 | 公平锁 | 公平锁 | | | | 可续租 | 天然支持，基于session | 天然支持，基于Lease | | | ##### 关于性能不太高的一种说法 > 因为每次在创建锁和释放锁的过程中，都要动态创建、销毁临时节点来实现锁功能。ZK中创建和删除节点只能通过Leader服务器来执行，然后Leader服务器还需要将数据同步到所有的Follower机器上，这样频繁的网络通信，性能的短板是非常突出的。在高性能，高并发的场景下，不建议使用ZooKeeper的分布式锁。 > > 由于ZooKeeper的高可用特性，在并发量不是太高的场景，也推荐使用ZK的分布式锁。 ## 4. InterProcessMutex 使用示例 ##### Zookeeper 客户端框架 Curator 提供的 InterProcessMutex 是分布式锁的一种实现，acquire 方法阻塞|非阻塞获取锁，release 方法释放锁，另外还提供了可撤销、可重入功能。 ##### 4.1 接口介绍 ``` // 获取互斥锁 public void acquire() throws Exception; // 在给定的时间内获取互斥锁 public boolean acquire(long time, TimeUnit unit) throws Exception; // 释放锁处理 public void release() throws Exception; // 如果当前线程获取了互斥锁，则返回true boolean isAcquiredInThisProcess(); ``` ##### 4.2 pom依赖 ``` org.apache.logging.log4j log4j-core 2.8.2 org.apache.zookeeper zookeeper 3.5.7 org.apache.curator curator-framework 4.3.0 org.apache.curator curator-recipes 4.3.0 org.apache.curator curator-client 4.3.0 ``` ##### 4.3 示例 ``` package com.atguigu.case3; 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; public class CuratorLockTest { public static void main(String[] args) { // 创建分布式锁1 InterProcessMutex lock1 = new InterProcessMutex(getCuratorFramework(), "/locks"); // 创建分布式锁2 InterProcessMutex lock2 = new InterProcessMutex(getCuratorFramework(), "/locks"); new Thread(new Runnable() { @Override public void run() { try { lock1.acquire(); System.out.println("线程1 获取到锁"); lock1.acquire(); System.out.println("线程1 再次获取到锁"); Thread.sleep(5 * 1000); lock1.release(); System.out.println("线程1 释放锁"); lock1.release(); System.out.println("线程1 再次释放锁"); } catch (Exception e) { e.printStackTrace(); } } }).start(); new Thread(new Runnable() { @Override public void run() { try { lock2.acquire(); System.out.println("线程2 获取到锁"); lock2.acquire(); System.out.println("线程2 再次获取到锁"); Thread.sleep(5 * 1000); lock2.release(); System.out.println("线程2 释放锁"); lock2.release(); System.out.println("线程2 再次释放锁"); } catch (Exception e) { e.printStackTrace(); } } }).start(); } private static CuratorFramework getCuratorFramework() { ExponentialBackoffRetry policy = new ExponentialBackoffRetry(3000, 3); CuratorFramework client = CuratorFrameworkFactory.builder().connectString("xxx:2181,xxx:2181,xxx:2181") .connectionTimeoutMs(2000) .sessionTimeoutMs(2000) .retryPolicy(policy).build(); // 启动客户端 client.start(); System.out.println("zookeeper 启动成功"); return client; } } ``` ## 5. DIY一个阉割版的分布式锁通过这个实例对照第2节内容来理解加解锁的流程，以及如何避免惊群效应。 ``` package com.rock.case2; import org.apache.zookeeper.*; import org.apache.zookeeper.data.Stat; import java.io.IOException; import java.util.List; import java.util.concurrent.CountDownLatch; /** * zk 分布式锁 v1版本: * 完成功能 : * 1. 避免了惊群效应 * 缺失功能: * 1. 超时控制 * 2. 读写锁 * 3. 重入控制 */ public class DistributedLock { private String connectString; private int sessionTimeout; private ZooKeeper zk; private CountDownLatch connectLatch = new CountDownLatch(1); private CountDownLatch waitLatch = new CountDownLatch(1); private String waitPath; private String currentNode; private String LOCK_ROOT_PATH; private static String NODE_PREFIX = "w"; public DistributedLock(String connectString, int sessionTimeout, String lockName) { //TODO:数据校验 this.connectString = connectString; this.sessionTimeout = sessionTimeout; this.LOCK_ROOT_PATH = lockName; } public void init() throws IOException, KeeperException, InterruptedException { // 建联 zk = new ZooKeeper(connectString, sessionTimeout, watchedEvent -> { // connectLatch 连接上zk后释放 if (watchedEvent.getState() == Watcher.Event.KeeperState.SyncConnected) { connectLatch.countDown(); } }); connectLatch.await();// 等待zk正常连接后 // 判断锁名称节点是否存在 Stat stat = zk.exists(LOCK_ROOT_PATH, false); if (stat == null) { // 创建一下锁名称节点 try { zk.create(LOCK_ROOT_PATH, LOCK_ROOT_PATH.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); } catch (KeeperException e) { //并发创建冲突忽略。 if (!e.code().name().equals("NODEEXISTS")) { throw e; } } } } /** * 待补充功能: * 1. 超时设置 * 2. 读写区分 * 3. 重入控制 */ public void zklock() throws KeeperException, InterruptedException { if (!tryLock()) { waitLock(); zklock(); } } /** * */ private void waitLock() throws KeeperException, InterruptedException { try { zk.getData(waitPath, new Watcher() { @Override public void process(WatchedEvent watchedEvent) { // waitLatch 需要释放 if (watchedEvent.getType() == Watcher.Event.EventType.NodeDeleted && watchedEvent.getPath().equals(waitPath)) { waitLatch.countDown(); } } }, new Stat()); // 等待监听 waitLatch.await(); } catch (KeeperException.NoNodeException e) { //如果等待的节点已经被清除了,不等了,再尝试去抢锁 return; } } private boolean tryLock() throws KeeperException, InterruptedException { currentNode = zk.create(LOCK_ROOT_PATH + "/" + NODE_PREFIX, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); // 判断创建的节点是否是最小的序号节点，如果是获取到锁；如果不是，监听他序号前一个节点 List children = zk.getChildren(LOCK_ROOT_PATH, false); // 如果children 只有一个值，那就直接获取锁；如果有多个节点，需要判断，谁最小 if (children.size() == 1) { return true; } else { String thisNode = currentNode.substring(LOCK_ROOT_PATH.length() + 1); // 通过w00000000获取该节点在children集合的位置 int index = children.indexOf(thisNode); if (index == 0) { //自己就是第一个节点 return true; } // 需要监听他前一个节点变化 waitPath = LOCK_ROOT_PATH + "/" + children.get(index - 1); } return false; } // 解锁 public void unZkLock() { // 删除节点 try { zk.delete(this.currentNode, -1); } catch (InterruptedException e) { e.printStackTrace(); } catch (KeeperException e) { e.printStackTrace(); } } } ``` ### 文末的补充(请关注，莫错过) 如果这篇文章对您有所帮助，或者有所启发的话，帮忙扫描下发二维码关注一下，关注公众号：**架构染色**，进行交流和学习。您的支持是我坚持写作最大的动力。 [求一键三连：点赞、收藏、转发。](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/69ca96a57f684a1eaea457ae145471b1~tplv-k3u1fbpfcp-zoom-1.image)