分布式锁
随着业务增长,我们部署了多个应用服务器。
架构变化:
单机:
用户 → 应用服务器 → Redis → 数据库
分布式:
用户 → 负载均衡 → 应用服务器 1 ━━━
→ 应用服务器 2 ━━━┳━→ Redis → 数据库
→ 应用服务器 3 ━━━
新问题:
场景:用户快速点赞
时间线:
T1: 用户点赞,请求到达服务器 A
T2: 服务器 A 检查未点赞,准备写入
T3: 用户取消点赞,请求到达服务器 B
T4: 服务器 B 检查已点赞,准备删除
T5: 服务器 A 写入点赞记录
T6: 服务器 B 删除点赞记录
结果:
- 服务器 A:用户已点赞
- 服务器 B:用户未点赞
→ 状态不一致!
原因:多服务器并发,没有协调机制。
解决方案:分布式锁。
核心思想:
- 在共享存储(如 Redis)中维护一个锁标记
- 获取锁的请求才能执行操作
- 其他请求等待或放弃
示意图:
正常情况(无锁):
服务器 A:读取 → 写入
服务器 B:读取 → 写入
→ 可能冲突
使用分布式锁:
服务器 A:获取锁 → 读取 → 写入 → 释放锁
服务器 B:等待锁...
服务器 A:释放锁
服务器 B:获取锁 → 读取 → 写入 → 释放锁
→ 串行执行,不会冲突
基础实现
Redis 分布式锁的最小可用版本需要三样东西:原子加锁、超时释放、只释放自己的锁。
import uuid
import time
# 释放锁的 Lua 脚本:比对 value 相等才删除,避免删掉别人的锁
RELEASE_SCRIPT = """
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
else
return 0
end
"""
class RedisLock:
"""Redis 分布式锁:SET NX PX + Lua 安全释放"""
def __init__(self, redis_client, key, expire_ms=30000, retry_interval=0.05):
self.redis = redis_client
self.key = key
self.expire_ms = expire_ms
self.retry_interval = retry_interval
self.token = None # 本次持锁的唯一标识
def acquire(self, timeout=3.0):
"""尝试加锁:成功返回 True,超时返回 False"""
token = str(uuid.uuid4())
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
ok = self.redis.set(
self.key, token,
nx=True, # 只有 key 不存在时才设置
px=self.expire_ms, # 同时设置过期时间
)
if ok:
self.token = token
return True
time.sleep(self.retry_interval)
return False
def release(self):
"""释放锁:只释放自己持有的那把"""
if not self.token:
return False
result = self.redis.eval(RELEASE_SCRIPT, 1, self.key, self.token)
self.token = None
return bool(result)
为什么必须用 SET key value NX PX 一条命令?
错误写法(两条命令):
SET key value
EXPIRE key 30000
如果两条命令之间进程崩溃 → key 永远不过期 → 死锁
SET 的 NX 和 PX 选项是 Redis 3.2 之后提供的,必须原子地一起设置。
为什么 value 要用随机 UUID?
value 是”锁的归属凭证”。释放锁时必须校验 value:
时间线:
T1: 实例 A 获取锁,value = uuid-A
T2: 实例 A 执行到一半,锁超时自动过期
T3: 实例 B 获取锁,value = uuid-B
T4: 实例 A 执行完毕,调用 release()
如果不校验 value → 实例 A 删掉了实例 B 的锁 ❌
校验 value → uuid-A != uuid-B → 不删除 ✅
这是分布式锁最经典的”自己删掉自己的锁过期后,别人已经拿到的锁”的问题。
为什么释放锁要用 Lua?
GET key → "uuid-A"
DEL key ← 两步,中间可能被别人重新加锁
DEL key → 1 ← 一步,但无法校验 value
GET 和 DEL 之间存在竞态窗口。Lua 脚本在 Redis 服务端原子执行,把”比对”和”删除”合成一个不可分割的操作。原理见《Lua 脚本》一章。
这个基础版本的三个缺陷:
1. 业务执行时间可能超过锁的过期时间。
锁 TTL:30 秒
业务耗时:45 秒(调用了三个下游服务)
T0: 实例 A 获取锁
T30: 锁自动过期
T31: 实例 B 获取锁(B 认为 A 已经死了)
T32: 实例 A 和实例 B 同时在改数据 ❌
2. 没有续期,长事务必须自己算准时间。
3. 只有一个 Redis 实例,单点故障。
后两个问题分别由”自动续期”和《Redlock 算法》解决。
改进:自动续期
自动续期的思路:加一个看门狗线程,只要业务还在运行,就周期性地把锁的 TTL 延长。
import threading
class AutoRenewRedisLock(RedisLock):
"""带自动续期的分布式锁"""
def __init__(self, redis_client, key, expire_ms=30000,
renew_interval=None):
super().__init__(redis_client, key, expire_ms)
# 续期间隔取 TTL 的 1/3,留出足够的重试余量
self.renew_interval = renew_interval or (expire_ms / 3000.0)
self._stop = threading.Event()
self._renew_thread = None
self._renew_failed = False
def _renew_once(self):
"""续期一次:只有 value 匹配时才延长"""
return self.redis.eval(
"""
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('pexpire', KEYS[1], ARGV[2])
else
return 0
end
""",
1, self.key, self.token, self.expire_ms,
)
def _renew_loop(self):
"""看门狗线程:周期续期,直到收到停止信号"""
while not self._stop.wait(self.renew_interval):
try:
ok = self._renew_once()
if not ok:
# value 不匹配 → 锁已经不属于我了
self._renew_failed = True
return
except Exception:
# 网络异常:继续重试,下一轮再续
# 但如果连续失败超过锁的 TTL,锁就没了
continue
def acquire(self, timeout=3.0):
if not super().acquire(timeout):
return False
self._stop.clear()
self._renew_failed = False
self._renew_thread = threading.Thread(target=self._renew_loop, daemon=True)
self._renew_thread.start()
return True
def release(self):
"""释放前先停掉续期线程"""
self._stop.set()
if self._renew_thread:
self._renew_thread.join(timeout=2)
self._renew_thread = None
return super().release()
@property
def is_held(self):
"""锁是否还在自己手里"""
return self.token is not None and not self._renew_failed
续期间隔为什么取 TTL 的 1/3?
TTL = 30 秒,续期间隔 = 10 秒
最坏情况:
T0 续期成功,TTL 重置为 30 秒
T10 续期线程被 GC 暂停 / 网络卡顿
T20 续期成功,TTL 重置为 30 秒
...
→ 只要两次续期的间隔 < TTL,锁就不会真正过期
如果间隔取 TTL 的 1/2:
T0 续期成功
T15 续期线程卡顿
T30 锁过期 ❌ 边界太危险
如果间隔取 TTL:
T0 续期成功
T30 续期时锁已经过期 → 续期失败 ❌
留 2 倍余量是为了容忍偶发的网络抖动和调度延迟。
续期脚本为什么也要校验 value?
如果续期时不校验 value:
T0: 实例 A 获取锁(uuid-A)
T30: A 卡住,锁过期
T31: 实例 B 获取锁(uuid-B)
T32: A 恢复,继续续期
如果不校验 → A 把 B 的锁续期了 ❌
B 会以为自己独享锁,实际 A 也在改数据
校验 → uuid-A != uuid-B → 续期失败,A 知道自己丢锁了 ✅
丢锁之后必须怎么办?
续期失败意味着你不再持有锁,此时继续写数据会破坏互斥。正确做法是中止业务并告警:
if not lock.is_held:
raise LockLostError("锁已丢失,中止本次操作")
很多实现会静默继续,这是很危险的——业务以为自己受保护,其实没有。
自动续期的三个风险点:
1. 业务死循环时锁永远不会释放。
看门狗会一直续期,直到业务结束。必须配一个最大持有时间兜底:
MAX_HOLD_MS = 60000 # 最多持锁 60 秒
2. 续期线程本身会挂。
看门狗是普通线程,可能因为异常、GC 停顿或进程挂起而停止工作。所以续期失败要能被观测到(打点 + 告警),不能只靠 is_held 被动检查。
3. 客户端进程崩溃时,看门狗也一起死了。
这时锁会按 TTL 自然过期——这是好事,说明 TTL 是唯一可靠的兜底。续期只是让”业务正常但耗时较长”的场景更安全。
自动续期 vs Redlock:
| 维度 | 单实例 + 续期 | Redlock |
|---|---|---|
| 单点故障 | 有(Redis 挂了全挂) | 多数派可用即可 |
| 长业务 | 支持(续期) | 同样需要续期 |
| 性能 | 1 次网络往返 | 5 次网络往返 |
| 复杂度 | 低 | 高 |
单实例加续期已经能覆盖大部分业务场景。只有对可用性要求极高、且能接受性能损耗的系统才值得上 Redlock。
问题:单点故障
单 Redis 实例的问题:
1. Redis 宕机
- 所有服务无法获取锁
- 系统不可用
2. 网络分区
- 应用服务器和 Redis 断连
- 可能导致多个锁
3. 时钟跳变
- 服务器时间调整
- 锁提前过期
Redlock 解决方案
原理:
- 使用多个独立的 Redis 实例(5 个)
- 在大多数实例上获取锁才算成功
- 降低单点故障风险
实现:
不同锁方案对比
| 方案 | 可用性 | 一致性 | 性能 | 复杂度 |
|---|---|---|---|---|
| 无锁 | 高 | 低 | 最高 | 低 |
| 单机锁 | 低 | 高 | 中 | 低 |
| 分布式锁(单 Redis) | 中 | 高 | 低 | 中 |
| Redlock | 高 | 高 | 低 | 高 |
性能测试
结论:锁会显著降低性能,但保证了一致性。
适合使用分布式锁的场景
1. 强一致性要求
- 金融交易
- 库存扣减
- 秒杀活动
2. 写冲突概率高
- 投票系统
- 限流计数
- ID 生成
3. 资源互斥
- 文件上传
- 任务调度
- 配置更新
不适合使用分布式锁的场景
1. 高并发读取
- 文章浏览
- 点赞查询
- 推荐列表
2. 可容忍不一致
- 点赞计数(最终一致)
- 统计数据
- 日志记录
3. 性能敏感
- 高频操作
- 实时性要求高
- 用户体验优先
点赞场景分析
点赞是否需要分布式锁?
分析:
1. 写冲突概率:低(不同用户点赞)
2. 一致性要求:中(最终一致即可)
3. 性能要求:高(高并发)
结论:
- 单用户对单文章:可以用唯一索引
- 单文章计数:可以用 INCR 原子操作
- 不需要分布式锁
例外场景:
- 用户快速点赞/取消:可以用乐观锁
- 批量操作:可以用分布式锁
练习 1
Redis 分布式锁如何防止”死锁”?
解题思路:
这道题问的是『持锁进程崩溃后锁永远不释放』的死锁,解法要从给锁加过期时间、以及保证只有持有者能解锁这两条线入手。
详细步骤:
死锁场景:
场景:服务器获取锁后崩溃
时间线:
T1: 服务器 A 获取锁
T2: 服务器 A 崩溃(进程退出)
T3: 锁未释放
T4: 其他服务器无法获取锁
→ 死锁!解决方案:
成因分析:
- 持锁进程崩溃 / 被 kill,finally 里的释放根本没有执行
- 释放请求因网络问题发出失败
- 锁根本没有过期时间 → 永远被占用
具体做法:
- 必带 TTL:
SET lock:xxx token NX EX 30000,一次性完成,避免 SET 与 EXPIRE 之间崩溃 - 解锁要验身份:用 Lua 脚本
if redis.call('get',KEYS[1])==ARGV[1] then return redis.call('del',KEYS[1]) end - TTL 要覆盖业务最长执行时间,长任务用看门狗续期
- 释放失败时靠 TTL 自然过期兜底
最终答案:
分布式锁必须带 TTL——获取锁时用 SET key token NX EX ttl 一次性写入并设置过期时间,即使持锁进程崩溃,锁也会自动到期释放;同时解锁时用 Lua 脚本比对 token(持有者标识)再删除,避免误删已被他人抢到的锁。TTL 要覆盖业务的最长执行时间,长任务用看门狗续期,释放失败则靠 TTL 自然过期兜底。
练习 2
分布式锁的”超时时间”如何设置?
解题思路:
这道题问的是 TTL 取值的权衡——TTL 太短会误释放、太长会拖慢故障恢复,所以要给出『按业务耗时推算』的方法和上下限。
详细步骤:
超时时间设置原则:
取值依据:
- TTL > 业务最长执行时间(取 P99 的 2~3 倍)
- TTL < 可接受的故障恢复时间上限
- 一次 SET 完成加锁 + 设置过期(
SET NX EX),不要先 SET 再 EXPIRE - 长任务用看门狗续期(每 TTL/3 续期一次)
反例:
- TTL 过短(1 秒)而业务耗时 5 秒 → 锁提前过期,两个客户端同时进入临界区
- TTL 过长(10 分钟)→ 进程崩溃后其他请求要等 10 分钟
最终答案:
超时时间按『业务最长执行时间 + 网络抖动余量』来定:先测出业务 P99 耗时,取其 23 倍作为 TTL 下限;同时设一个上限(如 3060 秒),避免一次崩溃把锁压住太久;长耗时业务用看门狗自动续期,而不是把 TTL 调得很大。
练习 3
Redlock 算法有什么缺点?
解题思路:
这道题问的是 Redlock 的代价,要从实现、性能、时钟、故障域、成本五个维度逐条列缺点,再给出替代方案。
详细步骤:
Redlock 的缺点:
1. 实现复杂
- 需要多个 Redis 实例
- 运维成本高
- 资源浪费
2. 性能差
- 需要访问多个实例
- 网络往返多
- 响应时间长
3. 时钟依赖
- 依赖服务器时钟同步
- 时钟跳变可能导致问题
- NTP 不稳定会影响
4. 故障域
- 网络分区时可能脑裂
- 多数派要求严格
- 恢复时间长
5. 成本高
- 需要更多 Redis 实例
- 硬件成本增加
- 维护成本增加替代方案:
1. 使用 ZooKeeper
- 优点:强一致性,可靠性高
- 缺点:性能差,复杂度高
2. 使用 etcd
- 优点:强一致性,支持租约
- 缺点:性能差,复杂度高
3. 使用数据库
- 优点:实现简单,可靠
- 缺点:性能差,数据库压力大
4. 重新设计,避免使用锁
- 优点:性能最好
- 缺点:设计复杂最终答案:
Redlock 的五个主要缺点是:实现复杂(需多个 Redis 实例、运维成本高)、性能差(每次加解锁都要访问多个实例、网络往返多)、依赖时钟同步(跳变会导致锁提前过期)、故障域风险(网络分区时可能脑裂,多数派要求严格、恢复时间长)、硬件成本高(需要更多实例)。替代方案包括 ZooKeeper/etcd(强一致但更慢)、数据库锁(简单可靠但性能差),以及最优解——重新设计以避免使用锁。
练习 4
如何实现”可重入”的分布式锁?
解题思路:
这道题问的是同一线程/同一请求重入时不能把自己锁死,解法核心是『锁的持有者标识要能计数』。
详细步骤:
可重入锁实现:
实现要点:
- 锁的 value 用『持有者唯一标识』:如
instanceId:threadId:requestId,不能只用一个随机串 - 重入计数单独存一个 key(如
lock:{name}:count),或用 Hash 字段存放 - 加锁逻辑(Lua 原子执行):
- key 不存在 → SET value NX EX ttl,count = 1
- key 存在且 value 等于自己 → count += 1,续期
- 否则 → 加锁失败
- 解锁逻辑:
- value 不等于自己 → 直接返回失败,不能删别人的锁
- count > 1 → count -= 1
- count = 1 → DEL key 并清空计数
注意:
- 重入必须有最大层数限制,否则递归调用可能无限加锁
- 计数和锁本身要在同一个 Lua 脚本里操作,避免中间态
最终答案:
可重入分布式锁要在 value 里记录持有者标识(如 instanceId:threadId:requestId)并额外维护一个重入计数器:首次加锁写 value 并把计数置为 1,再次加锁时先比对 value 是否等于自己,是则只把计数加一并续期,否则按普通竞争处理;解锁时同样用 Lua 脚本先验身份再把计数减一,减到 0 才真正删除 key。
练习 5
分布式锁如何实现”公平锁”?
解题思路:
这道题问的是『先来先得』而不是『谁抢到算谁的』,要说明 Redis 单条命令的原子性不足以保证顺序,得靠显式的排队结构。
详细步骤:
公平锁实现:
实现思路:
- 用 ZSET 维护等待队列:
lock:{name}:wait,score = 入队时间戳,member = 请求唯一标识 - 请求先 ZADD 入队,取回自己的 rank
- 轮询检查 rank 是否为 0;不是则等待重试(配合超时与退避)
- 成为队首后才执行真正的加锁(SET NX EX)
- 释放时把队首移出队列并通知下一个(Pub/Sub 唤醒,避免轮询空转)
注意事项:
- 排队要有超时上限,请求超时后要把自己从队列中移除,否则会堵塞整个队列
- 公平锁的等待时间不可控,不适合对延迟敏感的接口(如点赞);多数点赞场景更应该用原子计数而不是锁
最终答案:
公平锁靠显式排队实现:为每个锁维护一个 FIFO 队列(ZSET,score 为入队时间戳、member 为请求标识),请求先入队拿到自己的序号,只有轮到自己成为队首时才去执行加锁逻辑;获取成功后出队,释放时通知下一个等待者。简化做法是用 ZSET 取最小 member 作为『当前持有者』,只有它能加锁,从而保证排队顺序。
-
如果 Redis 主从切换,分布式锁会出问题吗?如何解决?
-
如何实现”读写锁”(多个读,一个写)?
-
分布式锁和”乐观锁”如何选择?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
