Redlock 算法
在上一节,我们实现了基于单 Redis 实例的分布式锁。
但在生产环境中,我遇到了一个严重问题:
故障场景:
T0: 正常运行,系统使用 Redis-1 作为锁服务
T1: Redis-1 所在服务器故障(宕机/网络断开)
T2: 所有应用服务器无法获取锁
T3: 系统不可用!
影响:
- 点赞功能全部停止
- 用户无法操作
- 业务严重受损
单点故障(SPOF)是分布式系统的大忌。
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 |
|---|---|---|
| 可用性 | 低(单点故障) | 高(多数派可用) |
| 一致性 | 高 | 高 |
| 性能 | 高(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 | 可用性 | 一致性 |
|---|---|---|---|---|
| 单实例锁 | 2 | 0.80ms | 低(单点) | 高 |
| Redlock(5 实例) | 10 | 3.57ms | 高 | 高(有脑裂争议) |
| Redlock(3 实例) | 6 | 2.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 算法为什么需要”大多数”实例成功?
解题思路:
这道题问的是多数派规则在数学上的作用,要从『两个互不相交的多数派不可能同时存在』这个交集性质讲起,再落到脑裂与容错。
详细步骤:
多数派原则:
为什么需要大多数(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 对时钟的依赖风险,要先说清时钟跳变会怎么破坏锁的有效期,再列工程上的应对手段。
详细步骤:
时钟跳变问题:
问题:
- 不同 Redis 实例时钟可能不同步
- 服务器时钟可能被手动调整
- NTP 同步可能跳变
影响:
- 锁提前过期
- 客户端误认为锁已释放
解决方案:
1. 使用 NTP 同步所有服务器时钟
2. 增加时钟偏差容错
3. 使用更长的 TTL
4. 监控时钟漂移最终答案:
时钟跳变会让锁提前过期或延后过期,导致持有者以为还持着锁、实际上已被他人获取。要靠工程手段兜住:用 NTP 同步所有实例时钟并监控漂移、把 TTL 设置得足够长以容纳允许的时钟偏差、在计算锁有效期时扣除一个时钟漂移余量、并配合看门狗对超时未释放的锁续期。
练习 3
Redlock 算法有哪些争议?
解题思路:
这道题问的是学界对 Redlock 的批评,要分『技术质疑』和『工程现实』两层,最后给出替代方案的定位。
详细步骤:
主要争议:
1. 时钟依赖
- Redlock 依赖系统时钟
- 时钟跳变可能导致问题
- Martin Kleppmann 的质疑
2. 网络分区
- 网络分区时可能出现脑裂
- 客户端可能长时间阻塞
3. 性能问题
- 需要访问多个实例
- 性能较差
4. 实现复杂
- 容易实现错误
- 难以测试
替代方案:
- ZooKeeper
- etcd
- 数据库最终答案:
主要争议集中在四点:依赖系统时钟(时钟跳变会破坏正确性,Martin Kleppmann 对此提出质疑)、网络分区时可能脑裂且客户端长时间阻塞、性能开销大(需访问多个实例)、实现复杂易出错且难以测试。工程上的替代方案是 ZooKeeper/etcd 的租约机制(强一致)或数据库锁(简单可靠),更好的做法是重新设计以避开分布式锁。
练习 4
如何实现 Redlock 的”公平锁”?
解题思路:
这道题问的是『Redlock 抢锁是不公平的,怎么改成先来先得』,要说明公平性必须在加锁之前用排队结构保证。
详细步骤:
公平 Redlock 实现:
实现要点:
- 排队队列:
redlock:{name}:wait,ZSET,score = 入队时间戳,member = 请求标识 - 入队后取回自己的 rank,只有 rank = 0 才尝试执行 Redlock 加锁
- 未轮到则等待重试(可结合 Pub/Sub 通知唤醒 + 超时兜底)
- 加锁成功后 ZREM 出队;释放锁时通知队首
- 请求超时或失败时必须把自己从队列移除,否则会堵住后续所有请求
注意:
- 公平锁的等待时间不可控,不适合延迟敏感接口
- 投票阶段的多数派获取本身就有竞争,公平性只能在『进入投票』这一层保证
最终答案:
在 Redlock 之上加一层排队:请求先进入一个 FIFO 队列(Redis ZSET,score 为入队时间戳)拿到序号,只有轮到自己成为队首时才执行 Redlock 的加锁流程;拿到锁后出队,释放时用 Pub/Sub 唤醒下一个等待者。Redlock 本身只保证互斥,公平性要靠队列显式实现,且请求超时必须把自己从队列里移除,否则会堵住后面的请求。
练习 5
Redlock 和 ZooKeeper 锁有什么区别?
解题思路:
这道题问的是两种分布式锁的实现哲学差异,要从一致性模型这个根子上对比,再落到选型。
详细步骤:
对比:
| 特性 | Redlock | ZooKeeper |
|---|---|---|
| 一致性模型 | 最终一致 | 强一致 |
| 实现复杂度 | 高 | 中 |
| 性能 | 低 | 很低 |
| 可用性 | 高 | 高 |
| 故障恢复 | 容易 | 复杂 |
| 成本 | 中 | 高 |
选择建议:
使用 Redlock:
- 已有 Redis 基础设施
- 性能要求相对较高
- 可容忍最终一致
使用 ZooKeeper:
- 强一致性要求
- 需要 watcher 机制
- 复杂的协调场景最终答案:
两者最根本的区别是一致性模型:Redlock 基于多个 Redis 实例的多数派投票,是最终一致(存在理论上的脑裂窗口),实现复杂、性能相对好、故障恢复容易;ZooKeeper 基于 ZAB 协议的强一致,通过写临时顺序节点 + watch 机制实现,可靠性更高但性能更低、故障恢复复杂、成本更高。选择上,已有 Redis 基础设施且可容忍最终一致用 Redlock;需要强一致与复杂协调(选主、跨资源互斥)用 ZooKeeper。
-
Redlock 算法在”网络分区”时如何保证正确性?
-
如何实现 Redlock 的”锁超时自动续期”?
-
Redlock 算法是否真的安全?有哪些已知的攻击方式?
💡 提示:这些问题没有标准答案,建议结合实际情况深入思考。
发现内容有问题?
告诉我们哪里需要改进。
