知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 07 - 分布式锁 ## 为什么需要分布式锁 ``` 单机环境:JVM 的 synchronized 或 ReentrantLock 可以保证线程安全 分布式环境:多个服务实例运行在不同机器上,JVM 锁无效 场景: 秒杀系统:100 件商品,1000 个并发请求,需要保证不超卖 定时任务:多个实例同时运行,需要保证只有一个实例执行 幂等控制:防止重复提交 ``` ## 基于 SETNX 的分布式锁 ### 最简单的实现 ```java // 加锁 boolean locked = redis.setnx("lock:order:1001", "1"); if (!locked) { return "获取锁失败,请稍后重试"; } try { // 执行业务逻辑 processOrder(1001); } finally { // 释放锁 redis.del("lock:order:1001"); } ``` ### 问题 1:加锁后宕机,锁永远不释放(死锁) ```java // 解决:加锁时设置过期时间 // 错误写法(两步操作不是原子的): redis.setnx("lock:order:1001", "1"); redis.expire("lock:order:1001", 30); // 如果这步执行前宕机,死锁! // 正确写法(原子操作): redis.set("lock:order:1001", "1", "NX", "EX", 30); // NX:不存在才设置(加锁) // EX 30:30 秒过期(防死锁) ``` ### 问题 2:锁被别人释放(误删) ``` 场景: 线程 A 加锁,执行业务逻辑 业务逻辑执行时间超过锁的过期时间(30 秒) 锁自动过期,线程 B 加锁成功 线程 A 执行完毕,删除锁 → 删掉了线程 B 的锁! 解决:锁的 value 存储唯一标识(如 UUID),释放时验证是否是自己的锁 ``` ```java String lockValue = UUID.randomUUID().toString(); // 加锁 redis.set("lock:order:1001", lockValue, "NX", "EX", 30); try { processOrder(1001); } finally { // 释放锁:先判断是否是自己的锁,再删除(必须是原子操作) // 错误写法(非原子): // if (lockValue.equals(redis.get("lock:order:1001"))) { // redis.del("lock:order:1001"); // 判断和删除之间可能被其他线程抢占 // } // 正确写法:使用 Lua 脚本保证原子性 String luaScript = """ if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end """; redis.eval(luaScript, 1, "lock:order:1001", lockValue); } ``` ### 问题 3:锁过期但业务还没执行完(锁续期) ```java // 解决:看门狗机制(Watchdog) // 加锁后启动一个后台线程,定期检查锁是否还需要续期 // Redisson 已经内置了看门狗机制: RLock lock = redisson.getLock("lock:order:1001"); lock.lock(); // 默认 30 秒过期,看门狗每 10 秒自动续期 try { processOrder(1001); } finally { lock.unlock(); } // 如果不想用看门狗,可以指定锁的超时时间(不会自动续期): lock.lock(10, TimeUnit.SECONDS); // 10 秒后自动释放,不续期 ``` ## Redisson 分布式锁(生产推荐) ### lock 和 tryLock 的区别 ``` lock:阻塞方式获取锁,获取失败会一直等待直到获取成功 tryLock:尝试获取锁,可指定 waitTime 进行阻塞等待 如果指定了 waitTime,在等待时间内会重试获取锁,超时返回 false 如果没指定 waitTime,未获取到锁时直接返回 false ``` ### 核心实现原理 ``` 1. 原子性:利用 SET key value NX PX 命令实现锁的抢占 2. 可重入性:锁的 value 中记录客户端 ID + 线程 ID + 重入次数(Hash 结构) 3. Lua 脚本:保证获取锁、释放锁、重入判断等操作的原子性 4. 看门狗机制:自动延长锁的过期时间,防止锁提前释放 锁在 Redis 中的存储结构(Hash): 键:myLock 值:{ "a1b2c3d4:123": 3 } // 线程 a1b2c3d4:123 重入了 3 次 ```  ### 获取锁的 Lua 脚本 ```lua -- KEYS[1]:锁名称 ARGV[1]:过期时间 ARGV[2]:客户端标识(UUID:线程ID) if (redis.call('exists', KEYS[1]) == 0) then -- 锁不存在:创建锁,重入次数设为 1,设置过期时间 redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return 1; end; if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then -- 锁已存在且为当前客户端持有:重入次数 +1,刷新过期时间 redis.call('hincrby', KEYS[1], ARGV[2], 1); redis.call('pexpire', KEYS[1], ARGV[1]); return 1; end; -- 锁被其他客户端持有:返回剩余过期时间 return redis.call('pttl', KEYS[1]); ``` ### 释放锁的 Lua 脚本 ```lua -- 先判断锁是否属于当前客户端 if (redis.call('hexists', KEYS[1], ARGV[2]) == 0) then return nil; -- 不属于当前客户端,防止误释放 end; -- 重入次数 -1 local counter = redis.call('hincrby', KEYS[1], ARGV[2], -1); if (counter > 0) then -- 重入次数仍 > 0,仅刷新过期时间 redis.call('pexpire', KEYS[1], ARGV[1]); return 0; else -- 重入次数 = 0,删除锁并发布解锁通知 redis.call('del', KEYS[1]); redis.call('publish', KEYS[2], ARGV[1]); return 1; end; ``` ### 看门狗机制(Watchdog) ``` 自动续租: 获取锁后,如果没有指定锁的超时时间 Watchdog 基于 Netty 时间轮启动后台任务 定期向 Redis 发送命令,重新设置锁的过期时间 续期时长:默认每 10 秒做一次续期,续期时长为 30 秒 停止续期:锁被释放或客户端实例关闭时,自动停止续租任务 续期的 Lua 脚本: if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then redis.call('pexpire', KEYS[1], ARGV[1]); return 1; end; return 0; ``` ```java // Redisson 使用示例 @Autowired private RedissonClient redisson; public void seckill(Long productId) { RLock lock = redisson.getLock("lock:product:" + productId); // 尝试加锁,等待 3 秒,锁超时 10 秒 boolean locked = lock.tryLock(3, 10, TimeUnit.SECONDS); if (!locked) { throw new RuntimeException("系统繁忙,请稍后重试"); } try { int stock = getStock(productId); if (stock <= 0) { throw new RuntimeException("库存不足"); } decreaseStock(productId); createOrder(productId); } finally { lock.unlock(); } } ``` ## Redlock(多节点分布式锁) ### 为什么需要 Redlock? ``` 单节点 Redis 的问题: 主节点加锁成功,还没同步到从节点,主节点宕机 从节点升为主节点,但没有这把锁的记录 另一个客户端在新主节点上加锁成功 → 两个客户端同时持有锁! Redlock 解决方案: 在 N 个独立的 Redis 节点上加锁(通常 5 个) 超过半数(N/2 + 1)加锁成功,才认为加锁成功 任何一个节点宕机,不影响锁的正确性 ``` ### Redlock 流程  *图:Redlock 向 5 个独立节点加锁的流程与判定条件* ``` 5 个独立 Redis 节点(不是主从,是完全独立的) Redlock 加锁流程: 客户端 │ ├── 1. 记录当前时间 T1 │ ├── 2. 依次向 5 个节点发送加锁请求(SET key value NX PX 30000) │ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │ │Redis1│ │Redis2│ │Redis3│ │Redis4│ │Redis5│ │ │ ✓ │ │ ✓ │ │ ✓ │ │ ✗ │ │ ✗ │ │ └──────┘ └──────┘ └──────┘ └──────┘ └──────┘ │ ↑ ↑ ↑ │ 成功 3/5 > 半数,加锁可能成功(还需检查耗时) │ ├── 3. 记录当前时间 T2,计算耗时 = T2 - T1 │ ├── 4. 判断条件: │ ① 成功节点数 ≥ N/2 + 1(这里是 3) ✓ │ ② 耗时 < 锁的有效时间(30000ms) ✓ │ → 加锁成功! │ 有效时间 = 30000 - (T2 - T1) - 时钟漂移余量 │ └── 5. 如果条件不满足 → 向所有节点发送解锁请求 → 加锁失败 释放锁: 向所有 5 个节点发送 Lua 解锁脚本 (验证 value 是否匹配 → 匹配才删除) 无论加锁时成功几个节点,释放时发给所有节点 Redlock 为什么比单节点更安全? 单节点 Redis: 主节点加锁 → 异步同步到从节点 → 主节点宕机 → 从节点升主但没有锁记录 → 新客户端成功加锁 → 两个持有者! Redlock: 5 个独立 Redis,没有主从关系 必须超过半数加锁成功 即使 2 个节点宕机,锁仍然正确 任意节点宕机不影响其他节点 ``` ```java // Redisson 实现 Redlock RedissonClient[] clients = {client1, client2, client3, client4, client5}; RLock[] locks = new RLock[5]; for (int i = 0; i < 5; i++) { locks[i] = clients[i].getLock("lock:order:1001"); } RedissonRedLock redLock = new RedissonRedLock(locks); redLock.lock(); try { // 业务逻辑 } finally { redLock.unlock(); } ``` ## Redis 锁的边界:为什么不是绝对强一致 ``` Redis 分布式锁能解决很多工程问题 但它不是严格意义上的强一致分布式锁 原因主要有: 1. Redis 主从复制是异步的 单节点或主从模式下,锁刚写到主节点就返回成功 还没同步到从节点时如果主节点宕机,锁可能丢失 2. 锁依赖超时时间 业务执行时间、GC 停顿、网络抖动、机器暂停 都可能让“锁还在不在”这个判断失真 3. 客户端和 Redis 之间没有共识协议 Redis 锁更像“高性能协调工具” 不是 Raft / Paxos 这类强一致协议下的租约锁 ``` ``` 所以它适合: 1. 定时任务防重 2. 幂等控制 3. 秒杀预扣、资源抢占 4. 尽量串行,而不是绝对串行 不适合: 1. 金融扣款这种强一致事务 2. 必须 100% 保证互斥的核心链路 3. 长事务、长时间持锁的大流程 ``` ### Fencing Token(面试加分项) ``` 即使有分布式锁,也可能出现“旧持锁者”在锁过期后继续操作资源的问题。 解决思路: 每次成功加锁时,都拿到一个单调递增的 token(栅栏令牌) 下游真实资源(如 DB / MQ / 文件服务)只接受 token 更大的请求 这样即使旧客户端还以为自己持有锁: 只要它的 token 更旧 下游也会拒绝它 ``` ``` 一句话理解: Redis 锁负责“尽量减少并发冲突” fencing token 负责“让下游识别谁才是最新的合法持有者” ``` ## 其他分布式锁实现方式 ### 基于 MySQL 实现 ``` 1. 基于唯一索引: 创建一张表,给锁名称字段添加唯一索引 并发插入时,插入成功 = 获取到锁,插入失败 = 未获取到锁 释放锁 = 删除这条数据 可设置锁过期时间,通过定时任务删除过期数据防止死锁 2. 基于悲观锁: 通过 SELECT ... FOR UPDATE 锁定数据库中的某一行 其他事务尝试修改这行数据时会被阻塞,直到锁被释放 任务完成后 COMMIT 提交事务自动释放锁 ``` ### 基于 ZooKeeper 实现 ``` 基于 ZooKeeper 的临时有序节点实现分布式锁: 加锁流程: 1. 在 ZK 中创建一个持久节点 ParentLock 2. 客户端 1 在 ParentLock 下创建临时顺序节点 Lock1 3. 客户端 1 查找所有临时顺序节点并排序,Lock1 是最小的 → 获取锁成功 4. 客户端 2 创建 Lock2,发现不是最小的 → 向 Lock1 注册 Watcher 监听 5. 每个节点监听前一个节点,形成等待队列 解锁流程: 任务完成:客户端显式删除自己的节点 客户端崩溃:临时节点自动删除,后续节点收到通知后获取锁 ``` ## 面试常见问题 **Q:如何用 Redis 实现分布式锁?有哪些坑?** A:用 `SET key value NX EX seconds` 原子命令加锁,value 存 UUID 防止误删,释放时用 Lua 脚本保证"判断 + 删除"的原子性。主要坑:① 加锁和设置过期时间要原子操作(用 SET NX EX,不要分两步);② 释放锁要验证是否是自己的锁(防误删);③ 业务执行时间可能超过锁的过期时间(用看门狗续期)。 **Q:Redlock 是什么?解决了什么问题?** A:Redlock 是基于多个独立 Redis 节点的分布式锁算法。解决了单节点 Redis 主从切换时锁丢失的问题——在 N 个独立节点上加锁,超过半数成功才算加锁成功,任何单节点故障不影响锁的正确性。 **Q:Redisson 的看门狗机制是什么?** A:Redisson 加锁后会启动一个后台线程(看门狗),每隔 10 秒检查业务是否还在执行,如果是则将锁的过期时间重置为 30 秒。这样即使业务执行时间超过 30 秒,锁也不会提前过期。如果服务宕机,看门狗停止续期,锁会在 30 秒后自动过期。 --- 上一篇:[06 - 缓存设计与常见问题](./06-cache-problems.md) | 下一篇:[08 - 事务与 Lua 脚本](./08-transaction-lua.md)
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入