分布式锁


分布式环境的新问题

随着业务增长,我们部署了多个应用服务器。

架构变化:

单机:
用户 → 应用服务器 → 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 分布式锁实现

基础实现

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。


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 分布式锁如何防止”死锁”?

分布式锁死锁Redis

解题思路:

这道题问的是『持锁进程崩溃后锁永远不释放』的死锁,解法要从给锁加过期时间、以及保证只有持有者能解锁这两条线入手。

详细步骤:

死锁场景:

场景:服务器获取锁后崩溃

时间线:
T1: 服务器 A 获取锁
T2: 服务器 A 崩溃(进程退出)
T3: 锁未释放
T4: 其他服务器无法获取锁
→ 死锁!

解决方案:

成因分析:

  • 持锁进程崩溃 / 被 kill,finally 里的释放根本没有执行
  • 释放请求因网络问题发出失败
  • 锁根本没有过期时间 → 永远被占用

具体做法:

  1. 必带 TTL:SET lock:xxx token NX EX 30000,一次性完成,避免 SET 与 EXPIRE 之间崩溃
  2. 解锁要验身份:用 Lua 脚本 if redis.call('get',KEYS[1])==ARGV[1] then return redis.call('del',KEYS[1]) end
  3. TTL 要覆盖业务最长执行时间,长任务用看门狗续期
  4. 释放失败时靠 TTL 自然过期兜底

最终答案:

分布式锁必须带 TTL——获取锁时用 SET key token NX EX ttl 一次性写入并设置过期时间,即使持锁进程崩溃,锁也会自动到期释放;同时解锁时用 Lua 脚本比对 token(持有者标识)再删除,避免误删已被他人抢到的锁。TTL 要覆盖业务的最长执行时间,长任务用看门狗续期,释放失败则靠 TTL 自然过期兜底。

练习 2

分布式锁的”超时时间”如何设置?

分布式锁超时设置性能

解题思路:

这道题问的是 TTL 取值的权衡——TTL 太短会误释放、太长会拖慢故障恢复,所以要给出『按业务耗时推算』的方法和上下限。

详细步骤:

超时时间设置原则:

取值依据:

  1. TTL > 业务最长执行时间(取 P99 的 2~3 倍)
  2. TTL < 可接受的故障恢复时间上限
  3. 一次 SET 完成加锁 + 设置过期(SET NX EX),不要先 SET 再 EXPIRE
  4. 长任务用看门狗续期(每 TTL/3 续期一次)

反例:

  • TTL 过短(1 秒)而业务耗时 5 秒 → 锁提前过期,两个客户端同时进入临界区
  • TTL 过长(10 分钟)→ 进程崩溃后其他请求要等 10 分钟

最终答案:

超时时间按『业务最长执行时间 + 网络抖动余量』来定:先测出业务 P99 耗时,取其 23 倍作为 TTL 下限;同时设一个上限(如 3060 秒),避免一次崩溃把锁压住太久;长耗时业务用看门狗自动续期,而不是把 TTL 调得很大。

练习 3

Redlock 算法有什么缺点?

Redlock分布式锁算法分析

解题思路:

这道题问的是 Redlock 的代价,要从实现、性能、时钟、故障域、成本五个维度逐条列缺点,再给出替代方案。

详细步骤:

Redlock 的缺点:

1. 实现复杂
   - 需要多个 Redis 实例
   - 运维成本高
   - 资源浪费

2. 性能差
   - 需要访问多个实例
   - 网络往返多
   - 响应时间长

3. 时钟依赖
   - 依赖服务器时钟同步
   - 时钟跳变可能导致问题
   - NTP 不稳定会影响

4. 故障域
   - 网络分区时可能脑裂
   - 多数派要求严格
   - 恢复时间长

5. 成本高
   - 需要更多 Redis 实例
   - 硬件成本增加
   - 维护成本增加

替代方案:

1. 使用 ZooKeeper
   - 优点:强一致性,可靠性高
   - 缺点:性能差,复杂度高

2. 使用 etcd
   - 优点:强一致性,支持租约
   - 缺点:性能差,复杂度高

3. 使用数据库
   - 优点:实现简单,可靠
   - 缺点:性能差,数据库压力大

4. 重新设计,避免使用锁
   - 优点:性能最好
   - 缺点:设计复杂

最终答案:

Redlock 的五个主要缺点是:实现复杂(需多个 Redis 实例、运维成本高)、性能差(每次加解锁都要访问多个实例、网络往返多)、依赖时钟同步(跳变会导致锁提前过期)、故障域风险(网络分区时可能脑裂,多数派要求严格、恢复时间长)、硬件成本高(需要更多实例)。替代方案包括 ZooKeeper/etcd(强一致但更慢)、数据库锁(简单可靠但性能差),以及最优解——重新设计以避免使用锁。

练习 4

如何实现”可重入”的分布式锁?

分布式锁可重入锁并发

解题思路:

这道题问的是同一线程/同一请求重入时不能把自己锁死,解法核心是『锁的持有者标识要能计数』。

详细步骤:

可重入锁实现:

实现要点:

  1. 锁的 value 用『持有者唯一标识』:如 instanceId:threadId:requestId,不能只用一个随机串
  2. 重入计数单独存一个 key(如 lock:{name}:count),或用 Hash 字段存放
  3. 加锁逻辑(Lua 原子执行):
    • key 不存在 → SET value NX EX ttl,count = 1
    • key 存在且 value 等于自己 → count += 1,续期
    • 否则 → 加锁失败
  4. 解锁逻辑:
    • value 不等于自己 → 直接返回失败,不能删别人的锁
    • count > 1 → count -= 1
    • count = 1 → DEL key 并清空计数

注意:

  • 重入必须有最大层数限制,否则递归调用可能无限加锁
  • 计数和锁本身要在同一个 Lua 脚本里操作,避免中间态

最终答案:

可重入分布式锁要在 value 里记录持有者标识(如 instanceId:threadId:requestId)并额外维护一个重入计数器:首次加锁写 value 并把计数置为 1,再次加锁时先比对 value 是否等于自己,是则只把计数加一并续期,否则按普通竞争处理;解锁时同样用 Lua 脚本先验身份再把计数减一,减到 0 才真正删除 key。

练习 5

分布式锁如何实现”公平锁”?

分布式锁公平锁调度算法

解题思路:

这道题问的是『先来先得』而不是『谁抢到算谁的』,要说明 Redis 单条命令的原子性不足以保证顺序,得靠显式的排队结构。

详细步骤:

公平锁实现:

实现思路:

  1. 用 ZSET 维护等待队列:lock:{name}:wait,score = 入队时间戳,member = 请求唯一标识
  2. 请求先 ZADD 入队,取回自己的 rank
  3. 轮询检查 rank 是否为 0;不是则等待重试(配合超时与退避)
  4. 成为队首后才执行真正的加锁(SET NX EX)
  5. 释放时把队首移出队列并通知下一个(Pub/Sub 唤醒,避免轮询空转)

注意事项:

  • 排队要有超时上限,请求超时后要把自己从队列中移除,否则会堵塞整个队列
  • 公平锁的等待时间不可控,不适合对延迟敏感的接口(如点赞);多数点赞场景更应该用原子计数而不是锁

最终答案:

公平锁靠显式排队实现:为每个锁维护一个 FIFO 队列(ZSET,score 为入队时间戳、member 为请求标识),请求先入队拿到自己的序号,只有轮到自己成为队首时才去执行加锁逻辑;获取成功后出队,释放时通知下一个等待者。简化做法是用 ZSET 取最小 member 作为『当前持有者』,只有它能加锁,从而保证排队顺序。


思考题

  1. 如果 Redis 主从切换,分布式锁会出问题吗?如何解决?

  2. 如何实现”读写锁”(多个读,一个写)?

  3. 分布式锁和”乐观锁”如何选择?

💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。

发现内容有问题?

告诉我们哪里需要改进。