Redlock 算法


单点故障问题

在上一节,我们实现了基于单 Redis 实例的分布式锁。

但在生产环境中,我遇到了一个严重问题:

故障场景:

T0: 正常运行,系统使用 Redis-1 作为锁服务
T1: Redis-1 所在服务器故障(宕机/网络断开)
T2: 所有应用服务器无法获取锁
T3: 系统不可用!

影响:
- 点赞功能全部停止
- 用户无法操作
- 业务严重受损

单点故障(SPOF)是分布式系统的大忌。


Redlock 算法原理

Redlock(Redis Distributed Lock) 是 Redis 作者 Antirez 提出的分布式锁算法。

核心思想:

  • 使用多个独立的 Redis 实例(通常 5 个)
  • 同时在这些实例上获取锁
  • 只有在大多数实例上获取成功才算真正获取到锁
  • 降低单点故障的影响

示意图:

单实例锁:
应用服务器 → Redis-1 → 锁
             ↑____________↑
        单点故障风险

Redlock:
应用服务器 → Redis-1 ━━
          → Redis-2 ━━┳━→ 获取大多数锁(3/5)
          → Redis-3 ━━┃
          → Redis-4 ━━┃
          → Redis-5 ━━┛

算法流程:

1. 获取当前时间戳 T1

2. 按顺序依次在 N 个 Redis 实例上获取锁
   - 使用相同的 key 和随机 value
   - 设置相同的过期时间
   - 每个实例获取锁的超时时间远小于锁的过期时间

3. 计算获取锁消耗的时间:T2 - T1

4. 判断是否成功:
   - 在大多数实例上获取成功(N/2 + 1)
   - 且获取锁的时间小于锁的过期时间

5. 如果成功,持有锁
   如果失败,释放所有已获取的锁

6. 释放锁:
   - 在所有实例上释放锁
   - 只有锁的 value 匹配才释放

完整方案

Redlock 类

Redlock 的核心是:在 N 个独立实例上依次尝试加锁,拿到多数派且耗时在有效期内才算成功。

import uuid
import time
import random


class Redlock:
    """Redlock 算法实现(Redis 官方推荐算法的 Python 移植)"""

    # 随机因子:避免同一进程在多个实例上用同一个 value
    RETRY_COUNT = 10
    RETRY_DELAY = 0.02

    def __init__(self, redis_clients, key, expire_ms=10000, drift_factor=0.01):
        """
        redis_clients: 多个独立 Redis 实例的客户端列表
        expire_ms:     锁的有效期
        drift_factor:  时钟漂移系数(用于补偿本地时钟的不确定性)
        """
        self.clients = list(redis_clients)
        self.key = key
        self.expire_ms = expire_ms
        self.drift_factor = drift_factor
        self.val = None
        self._start = None

    # ---- 内部方法 ----

    def _try_lock(self, client, token, ttl_ms):
        """在单个实例上加锁"""
        try:
            return bool(client.set(
                self.key, token,
                nx=True, px=ttl_ms,
            ))
        except Exception:
            # 单个实例不可用不影响整体,但要计入"未获得"
            return False

    def _unlock_instance(self, client, token):
        """在单个实例上释放锁(Lua 保证只释放自己的)"""
        try:
            return bool(client.eval(
                """
                if redis.call('get', KEYS[1]) == ARGV[1] then
                    return redis.call('del', KEYS[1])
                else
                    return 0
                end
                """,
                1, self.key, token,
            ))
        except Exception:
            return False

    # ---- 对外方法 ----

    def acquire(self, timeout=3.0):
        """尝试获取锁,成功返回 True"""
        token = f"{uuid.uuid4()}-{random.randint(0, 2 ** 32)}"
        ttl_ms = self.expire_ms

        # T1:记录开始时间
        start = time.monotonic()
        acquired_nodes = 0

        for client in self.clients:
            # T2:计算从开始到现在的时间
            elapsed = time.monotonic() - start
            # 剩余有效期要扣掉已经消耗的时间和时钟漂移
            drift = int(ttl_ms * self.drift_factor) + 2
            remaining = ttl_ms - int(elapsed * 1000) - drift

            # 剩余时间不够了,直接放弃
            if remaining <= 0:
                break

            if self._try_lock(client, token, remaining):
                acquired_nodes += 1

        # T3:计算总耗时
        elapsed_ms = (time.monotonic() - start) * 1000
        drift = int(ttl_ms * self.drift_factor) + 2

        # T4:判定成功条件
        #   1) 在大多数实例上获取成功
        #   2) 获取锁的总耗时小于有效期(扣掉漂移)
        majority = len(self.clients) // 2 + 1
        valid = elapsed_ms + drift < ttl_ms

        if acquired_nodes >= majority and valid:
            self.val = token
            self._start = start
            return True

        # 失败:释放所有已经获取的锁
        self._release_all(token)
        return False

    def release(self):
        """释放锁"""
        if not self.val:
            return False
        result = self._release_all(self.val)
        self.val = None
        return result

    def _release_all(self, token):
        """在所有实例上释放锁"""
        ok = False
        for client in self.clients:
            if self._unlock_instance(client, token):
                ok = True
        return ok

    def get_locked_time(self):
        """持锁时长(毫秒)"""
        if not self._start:
            return 0
        return int((time.monotonic() - self._start) * 1000)

四个关键实现细节:

1. value 必须是”每个实例不同”或”足够随机”。

错误:value = "lock"
    → 同一进程在 5 个实例上用同一个 value
    → 如果这个 value 泄露给了另一个客户端,它就能删掉你的锁

正确:value = uuid4() + 随机数

2. 每个实例的 TTL 要减去”已经消耗的时间”。

总耗时 3 秒,锁 TTL 10 秒
在第 4 个实例上尝试时,剩余有效期只有 7 秒
→ 给它的 TTL 应该是 7 秒,而不是 10 秒

如果给了 10 秒:这个实例上的锁会比其他实例活得久
→ 释放时顺序不一致 → 出现"有的实例已释放、有的还锁着"的窗口

3. 要扣掉时钟漂移(drift)。

节点之间的时钟不可能完全同步。本地时钟可能比真实时间慢几毫秒,所以有效期的判断要留出余量:

drift = ttl * 0.01 + 2ms

4. 失败时必须释放所有已获取的锁。

只拿下了 2/5 个实例但判定失败时,绝不能留着那 2 个锁不管——否则这些锁会一直占着到 TTL 到期。

使用示例

def like_article_with_lock(article_id, user_id):
    """用 Redlock 保护点赞写路径"""
    lock = Redlock(redis_clients, key=f"lock:article:{article_id}", expire_ms=10000)

    if not lock.acquire(timeout=1.0):
        raise LockAcquireTimeout("获取锁超时")

    try:
        # 临界区:所有实例串行执行
        if redis.sismember(f"article:{article_id}:liked_users", user_id):
            return {"liked": True, "changed": False}

        redis.sadd(f"article:{article_id}:liked_users", user_id)
        count = redis.incr(f"article:{article_id}:like_count")
        return {"liked": True, "changed": True, "like_count": count}
    finally:
        # 无论业务成功还是抛异常,都必须释放锁
        lock.release()

finally 里的释放不能省。

业务代码抛异常时如果不释放锁,锁会一直占着到 TTL 到期。这期间其他用户的点赞请求全部失败。

但要注意:finally 里的释放并不总是成功。

网络抖动可能导致释放失败。这时锁会等到 TTL 自然过期。所以TTL 必须覆盖业务的最长执行时间,并且要考虑”释放失败 + 等待 TTL”的兜底。

一个更实际的判断:点赞真的需要 Redlock 吗?

回顾本章的结论:
- 不同用户点赞不同文章 → 冲突概率极低,Redis INCR 就够了
- 同一用户快速点赞/取消 → 乐观锁或 Lua 脚本更合适
- 只有"跨资源的强互斥"才真正需要分布式锁

Redlock 的成本:
- 每次加锁 5 次网络往返
- 每次释放 5 次网络往返
- 延迟从 0.5ms 涨到 3ms 左右

结论:点赞计数本身不需要 Redlock。
     Redlock 适合的是"跨多个资源的事务性操作",
     比如"扣库存 + 生成订单 + 扣积分"这种场景。

Redlock 真正的适用场景:

- 秒杀:扣库存 + 记录订单,必须原子
- 分布式任务:保证同一任务同一时刻只有一个实例在执行
- 定时任务:多实例部署时防止重复执行
- 跨服务协调:多个微服务共同操作一组资源

上下文管理器

把 Redlock 包装成 Python 的上下文管理器,可以彻底避免忘记释放的问题。

from contextlib import contextmanager


class RedlockManager:
    """把 Redlock 包装成上下文管理器"""

    def __init__(self, redis_clients, key, expire_ms=10000):
        self.redis_clients = redis_clients
        self.key = key
        self.expire_ms = expire_ms

    @contextmanager
    def lock(self, timeout=3.0):
        """用法:with manager.lock(): ... """
        lock = Redlock(self.redis_clients, self.key, self.expire_ms)
        acquired = lock.acquire(timeout=timeout)
        try:
            if not acquired:
                raise LockAcquireTimeout(f"获取锁超时: {self.key}")
            yield lock
        finally:
            # 只有成功获取过才需要释放
            if acquired:
                lock.release()


# 使用方式
manager = RedlockManager(redis_clients, key="lock:stock:1001")

with manager.lock():
    # 临界区
    stock = redis.get("stock:1001")
    if int(stock) > 0:
        redis.decr("stock:1001")
        create_order()

相比 try/finally 的好处:

try/finally:
    lock = Redlock(...)
    if not lock.acquire():
        raise ...              ← 这一步容易漏写
    try:
        ...
    finally:
        lock.release()

上下文管理器:
    with manager.lock():
        ...                    ← 释放是自动的,漏不掉

上下文管理器还能返回锁对象,用于读取持锁时长等信息:

with manager.lock() as lock:
    do_something()
    elapsed = lock.get_locked_time()

嵌套锁要注意死锁。

with manager.lock(key="lock:a"):
    with manager.lock(key="lock:b"):   # 如果 A 和 B 互相持有 → 死锁
        ...

Redlock 没有提供死锁检测。要避免嵌套死锁,规则是:所有代码按固定顺序获取多把锁(比如永远先拿 lock:a 再拿 lock:b)。

一个容易被忽略的点:上下文管理器不会让”释放失败”消失。

finally 里的 lock.release() 同样可能因为网络问题失败。上下文管理器保证的是”一定会尝试释放”,不是”一定释放成功”。锁最终会靠 TTL 过期。


自动续期

Redlock 的 TTL 同样会遇到”业务没跑完锁就过期了”的问题,续期逻辑和单实例锁是一样的,只是要同时处理多个实例。

import threading


class AutoRenewRedlock:
    """带自动续期的 Redlock"""

    def __init__(self, redis_clients, key, expire_ms=10000,
                 renew_interval=None, max_hold_ms=None):
        self.lock = Redlock(redis_clients, key, expire_ms)
        self.expire_ms = expire_ms
        self.renew_interval = renew_interval or (expire_ms / 3000.0)
        # 最大持锁时间:防止业务死循环导致锁永不释放
        self.max_hold_ms = max_hold_ms or (expire_ms * 3)
        self._stop = threading.Event()
        self._thread = None
        self._lost = False

    def _renew_once(self):
        """在所有实例上续期:只有 value 匹配才算成功"""
        ok_count = 0
        for client in self.lock.clients:
            try:
                renewed = client.eval(
                    """
                    if redis.call('get', KEYS[1]) == ARGV[1] then
                        return redis.call('pexpire', KEYS[1], ARGV[2])
                    else
                        return 0
                    end
                    """,
                    1, self.lock.key, self.lock.val, self.expire_ms,
                )
                if renewed:
                    ok_count += 1
            except Exception:
                pass
        return ok_count

    def _renew_loop(self):
        """看门狗线程"""
        started = time.monotonic()
        while not self._stop.wait(self.renew_interval):
            # 超过最大持锁时间就停止续期,让锁自然过期
            if (time.monotonic() - started) * 1000 > self.max_hold_ms:
                self._lost = True
                return

            ok = self._renew_once()
            majority = len(self.lock.clients) // 2 + 1
            if ok < majority:
                # 多数派续期失败 → 锁已经不可靠,标记为丢失
                self._lost = True
                return

    def acquire(self, timeout=3.0):
        if not self.lock.acquire(timeout):
            return False
        self._stop.clear()
        self._lost = False
        self._thread = threading.Thread(target=self._renew_loop, daemon=True)
        self._thread.start()
        return True

    def release(self):
        self._stop.set()
        if self._thread:
            self._thread.join(timeout=2)
            self._thread = None
        return self.lock.release()

    @property
    def is_held(self):
        return self.lock.val is not None and not self._lost

Redlock 续期的判定标准比单实例更严。

单实例锁只要在一个实例上续期成功就算成功(因为那一个实例就是全部)。Redlock 要维持”多数派”这个性质,所以必须在多数实例上续期成功,否则锁的有效性已经无法保证。

5 个实例:
    续期成功 3 个 → 仍然持有多数派锁 ✅ 继续
    续期成功 2 个 → 多数派丢失 ❌ 标记为丢锁,停止续期

丢锁后必须中止业务。

if not auto_lock.is_held:
    raise LockLostError("锁已丢失,中止操作")

续期失败的三种情况要区分:

情况处理
少数实例网络异常继续重试,只要多数派还在就安全
多数实例不可达标记丢锁,中止业务
value 不匹配锁已被别人拿走,立即中止

故障场景测试

场景 1:单个实例故障

场景描述: 5 个实例中有 1 个宕机,Redlock 还能正常工作吗?

预期:能正常工作
理由:多数派(3/5)仍然可达,加锁成功
def test_single_node_failure():
    """场景 1:单个实例故障,锁仍能获取"""
    clients = [mock_client(i) for i in range(5)]
    # 让第 3 个实例宕机
    clients[2].fail = True

    lock = Redlock(clients, key="lock:test", expire_ms=10000)
    acquired = lock.acquire(timeout=1.0)

    assert acquired is True
    # 锁应该存在于 4 个可用实例中的 4 个
    locked_nodes = [c for c in clients if not c.fail and c.get("lock:test")]
    assert len(locked_nodes) == 4

    lock.release()
    # 释放后所有可用实例都不应再有锁
    assert all(c.get("lock:test") is None for c in clients if not c.fail)

为什么单实例故障不影响:

5 个实例,需要 3 个成功
挂掉 1 个 → 还剩 4 个 → 4 >= 3 ✅

什么时候会失效:

5 个实例,需要 3 个成功
挂掉 2 个 → 还剩 3 个 → 3 >= 3 ✅ 仍然可以(刚好够)
挂掉 3 个 → 还剩 2 个 → 2 < 3 ❌ 加锁失败

注意 Redis Cluster 的 sentinel 故障转移期间也可能出现短暂的”多数派不可达”。

运维建议:

- 5 个实例至少分布在 3 个物理机 / 可用区
- 不要把 5 个实例都放在同一台机器上(那样等于 1 个实例)
- 监控每个实例的健康状态,加锁失败率升高时要能定位到是哪些实例挂了

场景 2:网络分区

场景描述: 应用服务器和部分 Redis 实例之间发生网络分区。

时间线:
T0: 实例 A(客户端)能连通 Redis-1、Redis-2、Redis-3
T1: 网络分区 → A 只能连通 Redis-1、Redis-2
T2: 客户端 B(另一台机器)能连通 Redis-3、Redis-4、Redis-5
T3: 客户端 A 加锁 → 在 Redis-1、2 上成功(2 个),失败(3 >= 3 不满足)→ 判定失败
T4: 客户端 B 加锁 → 在 Redis-3、4、5 上成功 → 判定成功

关键点:分区后两侧都无法获得多数派,锁会被正确拒绝。

5 个实例,分区成 2 + 3:
    客户端 A 看到 2 个 → 2 < 3 → 加锁失败 ✅
    客户端 B 看到 3 个 → 3 >= 3 → 加锁成功

危险的情况是分区成 3 + 2,且客户端 A 已经持有锁。

T0: 客户端 A 获得多数派锁(3 个实例)
T1: 网络分区,A 只能看到 2 个实例
T2: 客户端 B 在另外 3 个实例上获得多数派锁
T3: A 和 B 都认为自己持有锁 ❌ 脑裂

Redlock 对这种情况并不完全免疫。 Martin Kleppmann 指出:客户端 A 在分区后可能还以为自己持有锁(它的本地状态没变),而客户端 B 在另一个多数派上拿到了锁。

缓解措施:

1. 设置合理的 TTL
   客户端 A 长时间联系不上实例时,锁会自然过期
   → 脑裂窗口被 TTL 限制住

2. 客户端感知分区后主动放弃锁
   续期失败(多数派联系不上)→ 标记丢锁 → 中止业务

3. 用 fencing token 防止"过期持有者"继续写入
   见下文

Fencing token 是最可靠的解法。

每次加锁时生成一个单调递增的 token(用 Redis 的 INCR 拿到全局唯一序号)
写入存储时带上这个 token
存储层拒绝比上次更小的 token

T0: 客户端 A 拿到 token=100,在 3 个实例上加锁
T1: 分区,A 联系不上多数派
T2: 客户端 B 拿到 token=101,在 3 个实例上加锁
T3: A 尝试写入,token=100 < 存储层记录的 101 → 被拒绝 ✅
T4: B 写入,token=101 → 接受 ✅

fencing token 把”时间锁”变成了”顺序锁”,彻底消除了脑裂的伤害。需要存储层配合(数据库加一列 last_token,写入时做条件判断)。

场景 3:时钟跳变

场景描述: 某台服务器的时钟突然向前或向后跳变。

向后跳变(时钟变慢)的影响:

T0:  客户端记录 T1 = 1000
T1:  本地时钟向后跳 500ms
T2:  客户端计算耗时 = T2 - T1,其中 T1 是跳变前记的
     → 耗时被算成 500ms 额外开销
     → 如果超过有效期,客户端会误判"加锁超时",把明明拿到的锁释放掉

这是安全方向的失败:误判失败 → 释放锁 → 锁的保护窗口缩短,但不会导致两个客户端同时持锁。

向前跳变(时钟变快)的影响:

T0:  客户端记录 T1 = 1000
T1:  本地时钟向前跳 500ms
T2:  客户端计算耗时 → 可能算出负数或极小的值 → 误判"加锁很快完成" ✅
T3:  但客户端已经超时判定失败 → 释放锁

同样是安全方向的失败。

真正危险的是”客户端之间的时钟不一致”,而不是单台机器跳变。

Redlock 的关键判定是”获取锁的总耗时 < 有效期”。这个判定用的是客户端自己的时钟,所以只需要客户端内部的时钟在加锁过程中是单调的。跨节点的时钟差通过 drift_factor 来容忍。

Redlock 官方对时钟的要求:
1. 客户端的时钟在计算耗时的过程中要单调(不能往回跳)
2. 考虑时钟漂移:drift = ttl * 0.01 + 2ms
3. 节点之间不需要严格同步时钟,只需要各自的 TTL 是相对时间

处理时钟跳变的工程手段:

1. 用 monotonic 时钟,不要用 wall clock
   Python:time.monotonic()  ✅  不受系统时间调整影响
           time.time()        ❌  会受 NTP 校时影响

2. 检测到时钟回拨时直接退出进程
   if current_time < last_time:
       os._exit(1)     ← 让编排系统重启我

3. 监控时钟漂移
   定期对比本地时间和 NTP 时间,偏差超过阈值就告警

在 Redlock 里使用 monotonic 时钟是必须的。

# 错误:用 time.time()
start = time.time()          # 系统时间可能被校时改动
elapsed = time.time() - start

# 正确:用 time.monotonic()
start = time.monotonic()     # 单调递增,不受系统时间影响
elapsed = time.monotonic() - start

时钟跳变场景的测试:

def test_clock_jump_backwards():
    """场景 3:时钟回拨不会导致两个客户端同时持锁"""
    # 模拟:加锁过程中"耗时"被算得极大
    # Redlock 判定 elapsed + drift < ttl 失败 → 释放锁 → 加锁失败
    # 结论:向安全方向失败,不会造成脑裂
    assert lock.acquire(timeout=1.0) is False
    # 释放后所有实例上都不应有残留锁
    assert all(c.get("lock:test") is None for c in clients)

Redlock vs 单实例锁

对比

特性单实例锁Redlock
可用性低(单点故障)高(多数派可用)
一致性高高
性能高(1 次网络往返)低(5 次网络往返)
复杂度低高
成本低(1 个 Redis)高(5 个 Redis)

性能测试

场景:1000 次加锁 + 释放,5 个独立实例(同一机房)

单实例锁:
- 加锁:1 次网络往返
- 释放:1 次网络往返(Lua)
- 合计:2 次往返
- 加锁 P50:0.42ms
- 释放 P50:0.38ms
- 合计 P50:0.80ms

Redlock:
- 加锁:最多 5 次网络往返(顺序访问)
- 释放:5 次网络往返
- 合计:10 次往返
- 加锁 P50:1.85ms
- 释放 P50:1.72ms
- 合计 P50:3.57ms
方案网络往返合计 P50可用性一致性
单实例锁20.80ms低(单点)高
Redlock(5 实例)103.57ms高高(有脑裂争议)
Redlock(3 实例)62.15ms中高

性能差距约 4.5 倍,主要来自网络往返数量。

优化空间:

1. 并行访问实例(而不是顺序)
   延迟从 5 × RTT 降到 1 × RTT
   代价:不再满足"按顺序访问"的要求
   → Redlock 官方允许并行,只是有效性判断会略保守

2. 释放时并行释放
   释放是 5 次独立操作,并行化没有一致性风险 ✅

3. 用 Pipeline 批量执行
   但 SET NX 的结果需要逐条判断,Pipeline 的收益有限

4. 只在业务真正需要时用 Redlock
   点赞计数这种场景用单实例锁或 Lua 脚本就够了

并行访问的代码变化:

# 顺序访问(官方推荐)
for client in self.clients:
    if self._try_lock(client, token, remaining):
        acquired_nodes += 1

# 并行访问(更快,但要处理线程同步)
with ThreadPoolExecutor(max_workers=len(self.clients)) as pool:
    futures = {
        client: pool.submit(self._try_lock, client, token, remaining)
        for client in self.clients
    }
    acquired_nodes = sum(1 for f in futures.values() if f.result())

压测代码:

import time
import statistics


def benchmark_lock(lock_factory, rounds=1000):
    """对比不同锁实现的加锁 + 释放耗时"""
    latencies = []

    for i in range(rounds):
        lock = lock_factory(f"lock:bench:{i}")
        t0 = time.monotonic()
        lock.acquire(timeout=1.0)
        lock.release()
        latencies.append((time.monotonic() - t0) * 1000)

    latencies.sort()
    return {
        "p50": round(statistics.median(latencies), 3),
        "p99": round(latencies[int(len(latencies) * 0.99)], 3),
        "max": round(latencies[-1], 3),
        "rounds": rounds,
    }


# 运行对比
single_result = benchmark_lock(lambda k: SingleLock(redis_client, k))
redlock_result = benchmark_lock(lambda k: Redlock(redis_clients, k))

print("单实例锁:", single_result)
print("Redlock:  ", redlock_result)
输出示例:
单实例锁: {'p50': 0.79, 'p99': 2.41, 'max': 8.72, 'rounds': 1000}
Redlock:   {'p50': 3.62, 'p99': 9.85, 'max': 21.34, 'rounds': 1000}

结论:Redlock 用 4.5 倍的延迟换取可用性的提升。

这个取舍是否值得,取决于业务对可用性的要求:

- 内部后台任务、对延迟不敏感 → 值得
- 用户直接感知的接口(点赞、搜索)→ 通常不值得
- 金融扣款等不能停服的场景 → 值得,且应配合 fencing token

适用场景

使用单实例锁:
- 开发/测试环境
- 可容忍短暂不可用
- 成本敏感
- 性能要求高

使用 Redlock:
- 生产环境
- 高可用要求
- 强一致性要求
- 成本不敏感

课后练习

练习 1

Redlock 算法为什么需要”大多数”实例成功?

Redlock分布式锁一致性

解题思路:

这道题问的是多数派规则在数学上的作用,要从『两个互不相交的多数派不可能同时存在』这个交集性质讲起,再落到脑裂与容错。

详细步骤:

多数派原则:

为什么需要大多数(N/2 + 1)?

1. 避免脑裂
   - 如果只需要少数,可能出现多个客户端同时持有锁
   - 示例:5 个实例,2 个即可
     - 客户端 A 在实例 1,2 获取锁
     - 客户端 B 在实例 3,4 获取锁
     - 两个客户端都认为自己持有锁

2. 保证唯一性
   - 大多数原则确保只有一个客户端能获取锁
   - 最多只能有一个多数派

3. 容错能力
   - 5 个实例,容忍 2 个故障
   - N 个实例,容忍 (N-1)/2 个故障

最终答案:

多数派(N/2 + 1)规则有两个理由:一是避免脑裂——任意两个多数派必有交集,因此不可能出现两个客户端同时在互不相交的多数派上持锁;二是保证容错——N 个实例可以容忍 (N-1)/2 个故障而多数派依然成立。代价是可用性下降:当可用实例不足多数派时,所有加锁请求都会失败。

练习 2

Redlock 算法如何处理”时钟跳变”?

Redlock时钟分布式系统

解题思路:

这道题问的是 Redlock 对时钟的依赖风险,要先说清时钟跳变会怎么破坏锁的有效期,再列工程上的应对手段。

详细步骤:

时钟跳变问题:

问题:
- 不同 Redis 实例时钟可能不同步
- 服务器时钟可能被手动调整
- NTP 同步可能跳变

影响:
- 锁提前过期
- 客户端误认为锁已释放

解决方案:
1. 使用 NTP 同步所有服务器时钟
2. 增加时钟偏差容错
3. 使用更长的 TTL
4. 监控时钟漂移

最终答案:

时钟跳变会让锁提前过期或延后过期,导致持有者以为还持着锁、实际上已被他人获取。要靠工程手段兜住:用 NTP 同步所有实例时钟并监控漂移、把 TTL 设置得足够长以容纳允许的时钟偏差、在计算锁有效期时扣除一个时钟漂移余量、并配合看门狗对超时未释放的锁续期。

练习 3

Redlock 算法有哪些争议?

Redlock争议分布式锁

解题思路:

这道题问的是学界对 Redlock 的批评,要分『技术质疑』和『工程现实』两层,最后给出替代方案的定位。

详细步骤:

主要争议:

1. 时钟依赖
   - Redlock 依赖系统时钟
   - 时钟跳变可能导致问题
   - Martin Kleppmann 的质疑

2. 网络分区
   - 网络分区时可能出现脑裂
   - 客户端可能长时间阻塞

3. 性能问题
   - 需要访问多个实例
   - 性能较差

4. 实现复杂
   - 容易实现错误
   - 难以测试

替代方案:
- ZooKeeper
- etcd
- 数据库

最终答案:

主要争议集中在四点:依赖系统时钟(时钟跳变会破坏正确性,Martin Kleppmann 对此提出质疑)、网络分区时可能脑裂且客户端长时间阻塞、性能开销大(需访问多个实例)、实现复杂易出错且难以测试。工程上的替代方案是 ZooKeeper/etcd 的租约机制(强一致)或数据库锁(简单可靠),更好的做法是重新设计以避开分布式锁。

练习 4

如何实现 Redlock 的”公平锁”?

Redlock公平锁调度

解题思路:

这道题问的是『Redlock 抢锁是不公平的,怎么改成先来先得』,要说明公平性必须在加锁之前用排队结构保证。

详细步骤:

公平 Redlock 实现:

实现要点:

  1. 排队队列:redlock:{name}:wait,ZSET,score = 入队时间戳,member = 请求标识
  2. 入队后取回自己的 rank,只有 rank = 0 才尝试执行 Redlock 加锁
  3. 未轮到则等待重试(可结合 Pub/Sub 通知唤醒 + 超时兜底)
  4. 加锁成功后 ZREM 出队;释放锁时通知队首
  5. 请求超时或失败时必须把自己从队列移除,否则会堵住后续所有请求

注意:

  • 公平锁的等待时间不可控,不适合延迟敏感接口
  • 投票阶段的多数派获取本身就有竞争,公平性只能在『进入投票』这一层保证

最终答案:

在 Redlock 之上加一层排队:请求先进入一个 FIFO 队列(Redis ZSET,score 为入队时间戳)拿到序号,只有轮到自己成为队首时才执行 Redlock 的加锁流程;拿到锁后出队,释放时用 Pub/Sub 唤醒下一个等待者。Redlock 本身只保证互斥,公平性要靠队列显式实现,且请求超时必须把自己从队列里移除,否则会堵住后面的请求。

练习 5

Redlock 和 ZooKeeper 锁有什么区别?

RedlockZooKeeper分布式锁

解题思路:

这道题问的是两种分布式锁的实现哲学差异,要从一致性模型这个根子上对比,再落到选型。

详细步骤:

对比:

特性RedlockZooKeeper
一致性模型最终一致强一致
实现复杂度高中
性能低很低
可用性高高
故障恢复容易复杂
成本中高

选择建议:

使用 Redlock:
- 已有 Redis 基础设施
- 性能要求相对较高
- 可容忍最终一致

使用 ZooKeeper:
- 强一致性要求
- 需要 watcher 机制
- 复杂的协调场景

最终答案:

两者最根本的区别是一致性模型:Redlock 基于多个 Redis 实例的多数派投票,是最终一致(存在理论上的脑裂窗口),实现复杂、性能相对好、故障恢复容易;ZooKeeper 基于 ZAB 协议的强一致,通过写临时顺序节点 + watch 机制实现,可靠性更高但性能更低、故障恢复复杂、成本更高。选择上,已有 Redis 基础设施且可容忍最终一致用 Redlock;需要强一致与复杂协调(选主、跨资源互斥)用 ZooKeeper。


思考题

  1. Redlock 算法在”网络分区”时如何保证正确性?

  2. 如何实现 Redlock 的”锁超时自动续期”?

  3. Redlock 算法是否真的安全?有哪些已知的攻击方式?

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

发现内容有问题?

告诉我们哪里需要改进。