redis分布式锁概念和图解

你的名字 2022-10-30 15:27 126阅读 0赞

谈起 Redis 锁，下面三个，算是出现最多的高频词汇：

*  **Setnx**
 *  **RedLock**
 *  **Redisson**

Setnx

目前通常所说的 Setnx 命令，并非单指 Redis 的 setnx key value 这条命令。

一般代指 Redis 中对 Set 命令加上 NX 参数进行使用，Set 这个命令，目前已经支持这么多参数可选：

SET key value [EX seconds|PX milliseconds] [NX|XX] [KEEPTTL]

当然了，就不在文章中默写 API 了，基础参数还有不清晰的，可以蹦到官网。

![1ce8e312ed169e9500a543798d0d9d3f.png][]

上图是笔者画的 Setnx 大致原理，主要依托了它的 Key 不存在才能 Set 成功的特性，进程 A 拿到锁，在没有删除锁的 Key 时，进程 B 自然获取锁就失败了。

那么为什么要使用 PX 30000 去设置一个超时时间？是怕进程 A 不讲道理啊，锁没等释放呢，万一崩了，直接原地把锁带走了，导致系统中谁也拿不到锁。

![ea2edf243d8b4df8a2670ae15e6bc88c.png][]

就算这样，还是不能保证万无一失。如果进程 A 又不讲道理，操作锁内资源超过笔者设置的超时时间，那么就会导致其他进程拿到锁，等进程 A 回来了，回手就是把其他进程的锁删了，如图：

![151137e37dd558106cfae3b8821cad2c.png][]

还是刚才那张图，将 T5 时刻改成了锁超时，被 Redis 释放。

进程 B 在 T6 开开心心拿到锁不到一会，进程 A 操作完成，回手一个 Del，就把锁释放了。

当进程 B 操作完成，去释放锁的时候（图中 T8 时刻）：

![bc439a761020e4e119789746cff014e0.png][]

找不到锁其实还算好的，万一 T7 时刻有个进程 C 过来加锁成功，那么进程 B 就把进程 C 的锁释放了。

以此类推，进程 C 可能释放进程 D 的锁，进程 D....(禁止套娃)，具体什么后果就不得而知了。

所以在用 Setnx 的时候，Key 虽然是主要作用，但是 Value 也不能闲着，可以设置一个唯一的客户端 ID，或者用 UUID 这种随机数。

当解锁的时候，先获取 Value 判断是否是当前进程加的锁，再去删除。伪代码：

String uuid = xxxx;
    // 伪代码，具体实现看项目中用的连接工具
    // 有的提供的方法名为set 有的叫setIfAbsent
    set Test uuid NX PX 3000
    try{
    // biz handle....
    } finally {
        // unlock
        if(uuid.equals(redisTool.get('Test')){
            redisTool.del('Test');
        }
    }

这回看起来是不是稳了？相反，这回的问题更明显了，在 Finally 代码块中，Get 和 Del 并非原子操作，还是有进程安全问题。

![f3b0a27281f0f0525e89ace9137a5be0.png][]

为什么有问题还说这么多呢？有如下两点原因：

*  搞清劣势所在，才能更好的完善。
 *  上文中最后这段代码，还是有很多公司在用的。

大小项目悖论：

*大公司实现规范，但是小司小项目虽然存在不严谨，可并发倒也不高，出问题的概率和大公司一样低。*

*-- 鲁迅*

![75ba78982a25c1206675769de433abe8.png][]

那么删除锁的正确姿势之一，就是可以使用 Lua 脚本，通过 Redis 的 eval/evalsha 命令来运行：

-- lua删除锁：
    -- KEYS和ARGV分别是以集合方式传入的参数，对应上文的Test和uuid。
    -- 如果对应的value等于传入的uuid。
    if redis.call('get', KEYS[1]) == ARGV[1] 
        then 
        -- 执行删除操作
            return redis.call('del', KEYS[1]) 
        else 
        -- 不成功，返回0
            return 0 
    end

**通过 Lua 脚本能保证原子性的原因说的通俗一点：** 就算你在 Lua 里写出花，执行也是一个命令（eval/evalsha）去执行的，一条命令没执行完，其他客户端是看不到的。

那么既然这么麻烦，有没有比较好的工具呢？就要说到 Redisson 了。

介绍 Redisson 之前，笔者简单解释一下为什么现在的 Setnx 默认是指 Set 命令带上 NX 参数，而不是直接说是 Setnx 这个命令。

因为 Redis 版本在 2.6.12 之前，Set 是不支持 NX 参数的，如果想要完成一个锁，那么需要两条命令：

1. setnx Test uuid
    2. expire Test 30

即放入 Key 和设置有效期，是分开的两步，理论上会出现 1 刚执行完，程序挂掉，无法保证原子性。

但是早在 2013 年，也就是 7 年前，Redis 就发布了 2.6.12 版本，并且官网(Set 命令页)，也早早就说明了“SETNX，SETEX，PSETEX 可能在未来的版本中，会弃用并永久删除”。

笔者曾阅读过一位大佬的文章，其中就有一句指导入门者的面试小套路，具体文字忘记了，大概意思如下： 说到 Redis 锁的时候，可以先从 Setnx 讲起，最后慢慢引出 Set 命令的可以加参数，可以体现出自己的知识面。

如果有缘你也阅读过这篇文章，并且学到了这个套路，作为本文的笔者我要加一句提醒：请注意你的工作年限！首先回答官网表明即将废弃的命令，再引出 Set 命令七年前的“新特性”，如果是刚毕业不久的人这么说，面试官会以为自己穿越了。

*你套路面试官，面试官也会套路你。  *

*-- vt・沃兹基硕德*

Redisson

Redisson 是 Java 的 Redis 客户端之一，提供了一些 API 方便操作 Redis。

但是 Redisson 这个客户端可有点厉害，笔者在官网截了仅仅是一部分的图：

![06d94432294b6356d4fb6f7424f305a7.png][]

这个特性列表可以说是太多了，是不是还看到了一些 JUC 包下面的类名，Redisson 帮我们搞了分布式的版本。

比如 AtomicLong，直接用 RedissonAtomicLong 就行了，连类名都不用去新记，很人性化了。

锁只是它的冰山一角，并且从它的 Wiki 页面看到，对主从，哨兵，集群等模式都支持，当然了，单节点模式肯定是支持的。

本文还是以锁为主，其他的不过多介绍。 Redisson 普通的锁实现源码主要是 RedissonLock 这个类，还没有看过它源码的盆友，不妨去瞧一瞧。

源码中加锁/释放锁操作都是用 Lua 脚本完成的，封装的非常完善，开箱即用。

这里有个小细节，加锁使用 Setnx 就能实现，也采用 Lua 脚本是不是多此一举？

笔者也非常严谨的思考了一下：这么厉害的东西哪能写废代码？

![cba55e9357097ec9be140d211c10a439.png][]

其实笔者仔细看了一下，加锁解锁的 Lua 脚本考虑的非常全面，其中就包括锁的重入性，这点可以说是考虑非常周全，我也随手写了代码测试一下：

![b74927522f3ccaeff5bc77d20ca22253.png][]

的确用起来像 JDK 的 ReentrantLock 一样丝滑，那么 Redisson 实现的已经这么完善，RedLock 又是什么？

RedLock

![86a53cd2b11c97417ab3dd40c847dfaf.png][]

RedLock的中文是直译过来的，就叫红锁。 红锁并非是一个工具，而是 Redis 官方提出的一种分布式锁的算法。

就在刚刚介绍完的 Redisson 中，就实现了 RedLock 版本的锁。也就是说除了 getLock 方法，还有 getRedLock 方法。

笔者大概画了一下对红锁的理解：

![f3e188b681e2494ba4634a41ce6b6dc4.png][]

如果你不熟悉 Redis 高可用部署，那么没关系。RedLock 算法虽然是需要多个实例，但是这些实例都是独自部署的，没有主从关系。

RedLock 作者指出，之所以要用独立的，是避免了 Redis 异步复制造成的锁丢失，比如：主节点没来的及把刚刚 Set 进来这条数据给从节点，就挂了。

有些人是不是觉得大佬们都是杠精啊，天天就想着极端情况。其实高可用嘛，拼的就是 99.999...% 中小数点后面的位数。

回到上面那张简陋的图片，红锁算法认为，只要 2N+1 个节点加锁成功，那么就认为获取了锁， 解锁时将所有实例解锁。

流程为：

*  **顺序向五个节点请求加锁**
 *  **根据一定的超时时间来推断是不是跳过该节点**
 *  **三个节点加锁成功并且花费时间小于锁的有效期**
 *  **认定加锁成功**

也就是说，假设锁 30 秒过期，三个节点加锁花了 31 秒，自然是加锁失败了。

这只是举个例子，实际上并不应该等每个节点那么长时间，就像官网所说的那样，假设有效期是 10 秒，那么单个 Redis 实例操作超时时间，应该在 5 到 50 毫秒(注意时间单位)。

还是假设我们设置有效期是 30 秒，图中超时了两个 Redis 节点。那么加锁成功的节点总共花费了 3 秒，所以锁的实际有效期是小于 27 秒的。

即扣除加锁成功三个实例的 3 秒，还要扣除等待超时 Redis 实例的总共时间。 看到这，你有可能对这个算法有一些疑问，那么你不是一个人。

回头看看 Redis 官网关于红锁的描述，就在这篇描述页面的最下面，你能看到著名的关于红锁的神仙打架事件。

![5e3abca2eb1c3fbee7cc82cc4dc8e0fb.png][]

即 Martin Kleppmann 和 Antirez 的 RedLock 辩论。一个是很有资历的分布式架构师，一个是 Redis 之父。

官方挂人，最为致命。 开个玩笑，要是质疑能被官方挂到官网，说明肯定是有价值的。

所以说如果项目里要使用红锁，除了红锁的介绍，不妨要多看两篇文章，即：

*  **Martin Kleppmann 的质疑贴**
 *  **Antirez 的反击贴**

总结

看了这么多，是不是发现如何实现，都不能保证 100% 的稳定。 程序就是这样，没有绝对的稳定，所以做好人工补偿环节也是重要的一环，毕竟：技术不够，人工来凑！

[1ce8e312ed169e9500a543798d0d9d3f.png]: /images/20221024/f66e508331334b6db739c21a790cb376.png
[ea2edf243d8b4df8a2670ae15e6bc88c.png]: /images/20221024/93e2ff94b6f2472e9deea554f4780354.png
[151137e37dd558106cfae3b8821cad2c.png]: /images/20221024/9141eac0a1fd488281d5f5ac2089a71d.png
[bc439a761020e4e119789746cff014e0.png]: /images/20221024/8d28bb43904c4989815667b72b10b4b9.png
[f3b0a27281f0f0525e89ace9137a5be0.png]: /images/20221024/55d3bbe9d0b44fe1a42a0c9bcefad839.png
[75ba78982a25c1206675769de433abe8.png]: /images/20221024/c837390f1160402d979ff279048874cb.png
[06d94432294b6356d4fb6f7424f305a7.png]: /images/20221024/13c2578fda7c47adb7df1d69433f6bc8.png
[cba55e9357097ec9be140d211c10a439.png]: /images/20221024/f26300ce8ea549c3a3ff4460d21d0a73.png
[b74927522f3ccaeff5bc77d20ca22253.png]: /images/20221024/70ef9b43634a4aeaa8f2834097ecdf13.png
[86a53cd2b11c97417ab3dd40c847dfaf.png]: /images/20221024/c02beac04d47410b8f80b4762a898dfb.png
[f3e188b681e2494ba4634a41ce6b6dc4.png]: /images/20221024/55c8c233276f439d9ac0b3d5ac8f86a5.png
[5e3abca2eb1c3fbee7cc82cc4dc8e0fb.png]: /images/20221024/e7b2b5d5e20a4053aeb44d02707ef07b.png