罗罗编程学习记录
本页内容 展开查看

06.5.8.3 Redis 分布式锁与 Lua

所属:全栈开发面试题库 / 06 后端框架与工程实践 / 06.5 PHP 后端 / 06.5.8 PHP 配套技术栈

06.5.8.3-001 为什么 SET key value NX EX 30 是加锁正确姿势?

一句话结论

加锁必须把「不存在才设置」与「带过期时间」合在一条原子命令里:SET key <唯一值> NX EX <秒>;分开的 SETNX 与 EXPIRE 不是原子操作,进程崩溃会留下无 TTL 的死锁。

概念解释

NX 保证 key 不存在才写入,实现互斥;EX 给锁加过期兜底,防止持锁者宕机后锁永久残留。两条命令分开执行时,SETNX 成功后、EXPIRE 前进程异常退出,key 没有过期时间,其他节点永远抢不到。单条 SET 原子完成两件事。

原理流程

  1. 生成锁的唯一标识值(随机串或实例 + 线程标识)。
  2. 执行 SET lock:<资源> <唯一值> NX EX <超时秒>。
  3. 返回成功即获得锁;返回 nil 表示已被持有。
  4. 临界区执行完,按唯一值安全释放锁。

代码或图示

$token = bin2hex(random_bytes(16));
$lockKey = "lock:order:{$orderId}";
$ok = $redis->set($lockKey, $token, ['NX', 'EX' => 30]);
if (!$ok) { throw new RuntimeException("订单正在处理,请勿重复提交"); }

常见误区

  • 先 SETNX 再 EXPIRE:两步之间崩溃即死锁。
  • 只设 NX 不设过期:持锁者异常后锁永不释放。

追问

  • PX 与 EX 区别?答:PX 毫秒级过期,EX 秒级;短临界区可用毫秒精度。
  • 返回值怎么判断?答:phpredis 成功返回 true,未抢到返回 false/nil,按扩展版本核对返回类型,待确认项以扩展文档为准。

06.5.8.3-002 锁的 value 为什么必须是唯一随机值?

一句话结论

value 必须是每次加锁生成的唯一标识,释放时先比对标识再删除,防止 A 持锁超时后被 B 抢到,A 退出时误删 B 的锁;固定值或空值无法识别锁归属。

概念解释

锁有超时兜底,业务执行超过 TTL 时锁可能自动释放,其他节点进入临界区。若释放时不校验归属直接删 key,前一个持锁者会删掉新持锁者的锁。唯一标识(随机串 + 节点/线程信息)让每次加锁可区分,释放时只删自己的锁。

原理流程

  1. 加锁时生成全局唯一 token,写入锁 value。
  2. 临界区结束准备释放。
  3. 读取 value 与本地 token 比对,一致才删除。
  4. 比对与删除必须用 Lua 保证原子。

代码或图示

$token = bin2hex(random_bytes(16));
$redis->set($lockKey, $token, ['NX', 'EX' => 30]);
// 释放前比对:只有 value 等于本 token 才删除
$stored = $redis->get($lockKey);
if ($stored === $token) { $redis->del($lockKey); }

常见误区

  • value 写固定字符串 "lock":无法判断当前锁属于谁,误删不可避免。
  • token 用自增 ID 可被预测:释放比对虽可用,但跨节点建议随机串,避免取值冲突。

追问

  • 比对后删除为什么还要原子化?答:GET 与 DEL 之间锁可能过期并被他人重入,非原子比对仍会误删,见下一题。
  • token 存哪里?答:本次请求上下文内保存,不入库不跨请求复用。

06.5.8.3-003 释放锁为什么要用 Lua 保证「比对 + 删除」原子性?

一句话结论

比对 value 与删除 key 分两步会在中间窗口丢失锁归属:Lua 脚本在 Redis 中单线程串行执行,比对一致才删除,整个过程不可被其他命令插入。

概念解释

普通 GET 后判断再 DEL 是两条命令:读到匹配值后、执行 DEL 前,锁可能已过期并被另一节点持有,此时 DEL 删掉新锁。Lua 在服务端一次执行完「读 value → 相等则删 → 返回结果」,期间不穿插其他客户端命令。

原理流程

  1. 把锁 key 与 token 传给 Lua 脚本。
  2. 脚本读取 key 对应 value。
  3. value 等于 token:删除 key,返回 1;不等返回 0。
  4. 客户端按返回值判断锁是否由自己释放。

代码或图示

$script = <<<'LUA'
if redis.call("GET", KEYS[1]) == ARGV[1] then
    return redis.call("DEL", KEYS[1])
else
    return 0
end
LUA;
$redis->eval($script, [$lockKey, $token], 1);

常见误区

  • 释放直接 DEL:不校验归属,误删他人锁。
  • 用 GET 校验后 DEL:两步非原子,窗口内仍可能误删。

追问

  • eval 与 evalSha 区别?答:eval 每次传脚本体;evalSha 传脚本 SHA1,服务端缓存脚本后省带宽,脚本未缓存需回退 eval。
  • Lua 里能做复杂业务判断吗?答:只做锁归属判断这类原子小逻辑;复杂编排应在应用层完成。

06.5.8.3-004 可重入锁在 Redis 单节点如何实现?

一句话结论

可重入指同一持锁者在临界区内再次获取同一把锁不被自己挡住,实现方式是用 Hash 存「持有者标识 + 重入次数」,重入时次数 +1,退出时 -1,次数归 0 才删锁。

概念解释

普通互斥锁同一线程二次加锁会失败,嵌套调用场景需要可重入。Hash 结构:field 存持有者 token,value 存重入计数。加锁:key 不存在则建 Hash 计数 1;存在且 field 是自己则计数 +1;不是自己则失败。释放:计数 -1,归零删除。

原理流程

  1. 首次加锁:HSET lock owner <token> count 1,设 TTL。
  2. 重入:判断 owner 是本 token,HINCRBY count 1。
  3. 退出一层:HINCRBY count -1,count 为 0 删除 key。
  4. 全程用 Lua 保证判断与计数原子。

代码或图示

// 伪 Lua:可重入加锁(示意,字段与参数按实现定稿)
// if redis.call("EXISTS", KEYS[1]) == 0 then
//   redis.call("HSET", KEYS[1], "owner", ARGV[1], "count", 1)
//   redis.call("EXPIRE", KEYS[1], ARGV[2]); return 1
// elseif redis.call("HGET", KEYS[1], "owner") == ARGV[1] then
//   redis.call("HINCRBY", KEYS[1], "count", 1); return 1
// else return 0 end

常见误区

  • 重入计数不归零:外层退出后 key 残留,其他节点进不来。
  • 重入不刷新 TTL:嵌套执行时间长,锁中途过期被他人抢占。

追问

  • 可重入锁需要续期吗?答:需要,长临界区仍应看门狗续期,重入期间保持 TTL 有效。
  • PHP 嵌套调用怎么标识持有者?答:token 在请求级上下文生成,同一次请求内各层复用同一 token。

06.5.8.3-005 锁超时与业务时长不匹配时如何续期?

一句话结论

业务执行可能超过初始 TTL 时,需要看门狗(watchdog)后台续期:持锁期间定期检查仍持有则延长 TTL,执行结束停止续期;PHP FPM 短请求模型下更应把临界区做短,避免依赖长续期。

概念解释

初始 TTL 是崩溃兜底,不能设得过长;业务时长不确定时由后台线程/协程在到期前续期。续期只对自己持有的锁生效,续期前比对 token。PHP FPM 进程内没有常驻线程,续期能力受限;常驻框架或独立定时任务才能稳定看门狗,未装 swoole/swow 的环境不要假设协程后台。

原理流程

  1. 加锁时设定初始过期时间(如 30 秒)。
  2. 后台续期任务在到期前 1/3 周期检查锁仍归本 token。
  3. 归属一致:执行 EXPIRE 延长;归属丢失:停止续期。
  4. 临界区退出后关闭续期任务,删除锁。

代码或图示

// 续期 Lua:仍是本持有者才延长过期
$script = <<<'LUA'
if redis.call("GET", KEYS[1]) == ARGV[1] then
    return redis.call("EXPIRE", KEYS[1], ARGV[2])
else
    return 0
end
LUA;
// 续期由后台调度触发;FPM 请求内不依赖 sleep 轮询续期

常见误区

  • 临界区很慢又不续期:锁提前过期,两个节点同时进入临界区。
  • 续期不校验归属:锁已被他人持有,续期命令延长了别人的锁。

追问

  • 续期周期怎么定?答:一般为 TTL 的 1/3 左右;具体间隔按压测与任务时长定,未实测前标注待确认。
  • 没有看门狗能力怎么办?答:缩短临界区、把慢操作移出锁内,初始 TTL 按最坏执行时长保守设定。

06.5.8.3-006 锁粒度怎么设计?

一句话结论

锁按资源最小可争用单元划分:订单级、用户级、商品级优于方法级/全局级;粒度越粗并发度越低,粒度越细越接近真实竞争,同时要避免锁过多带来的管理成本。

概念解释

锁粒度决定互斥范围:全局锁把所有请求串行化,资源级锁只互斥同一对象的并发。设计时先找真正需要排他的资源标识(订单 ID、库存 SKU),把不冲突的操作放开。锁 key 包含业务域与资源 ID,便于排查与批量管理。

原理流程

  1. 找出临界区需要排他的资源实体与标识。
  2. 以资源 ID 组装锁 key,如 lock:stock:{skuId}。
  3. 评估临界区是否跨多个资源,跨资源时考虑顺序加锁避免死锁。
  4. 复盘锁竞争度,过粗则细化,过细则评估批量合并。

代码或图示

// 订单级锁:只互斥同一订单的并发操作
$lockKey = "lock:order:{$orderId}";
// 反例:全局锁 lock:submit,所有下单请求串行

常见误区

  • 用方法名当锁 key:同一方法操作不同资源也被互斥,并发度被无谓拉低。
  • 锁粒度细到每条记录却在锁内做远程调用:持锁时间长,细粒度收益被抵消。

追问

  • 一次操作锁多个资源怎么办?答:按固定顺序加锁(如按 ID 升序),避免交叉持有形成死锁。
  • 锁 key 命名规范?答:lock:<业务>:<资源类型>:<标识>,与普通缓存 key 前缀区分。

06.5.8.3-007 持锁进程崩溃后锁如何释放?

一句话结论

依赖锁的 TTL 过期自动释放:持锁者异常退出不会执行释放,key 到期后其他节点可重新获取;TTL 是崩溃场景的唯一兜底,因此不能省略。

概念解释

分布式锁没有进程内的析构保证,持锁节点断电、进程被杀、网络断开都不会走到释放逻辑。服务端按过期时间淘汰 key,其余请求在到期后抢锁。TTL 取值要平衡:过短误释放正常业务,过长崩溃后阻塞等待久。

原理流程

  1. 加锁时写入 EX/PX 过期时间。
  2. 持锁者正常退出:主动比对删除。
  3. 持锁者崩溃:不执行删除,等待 TTL 到期服务端回收。
  4. 到期后其他节点重试加锁成功进入临界区。

代码或图示

// 崩溃兜底:TTL 必须存在;未抢到锁时稍后重试
$ok = $redis->set($lockKey, $token, ['NX', 'EX' => 30]);
if (!$ok) {
    usleep(100 * 1000); // 短暂等待后重试,次数设上限
}

常见误区

  • 以为释放逻辑一定会执行:异常路径(致命错误、断电)到不了释放代码。
  • TTL 设过长:崩溃后锁残留时间久,业务长时间不可用。

追问

  • 怎么缩短崩溃阻塞?答:按临界区时长保守设 TTL,并配续期机制;崩溃恢复速度取决于 TTL。
  • 锁残留如何排查?答:扫描 lock: 前缀 key,查看 TTL 与剩余时间,判断是否为崩溃残留。

06.5.8.3-008 主从异步复制为什么会导致锁丢失?

一句话结论

主节点写锁后、复制到从节点前宕机,故障切换后新主上没有这条锁记录,其他节点可再次加锁,互斥被突破;这是 Redis 主从复制异步语义下分布式锁的固有风险。

概念解释

SET NX 写在主节点,返回成功后锁信息通过复制链路异步同步从节点。主节点尚未把锁传给从节点即宕机,哨兵/集群提升从节点为主,新主缺失该 key。业务侧以为持锁成功,实际新主允许重复加锁。风险窗口很小但在强互斥场景不可忽略。

原理流程

  1. 客户端在主节点加锁成功,收到返回。
  2. 锁 key 异步复制到从节点,存在传输延迟。
  3. 主节点在复制完成前故障,从节点提升为新主。
  4. 新主无锁记录,另一客户端加锁成功,临界区被并发进入。

代码或图示

// 主从切换风险示意:加锁返回成功不等于锁已持久化到多数节点
// $redis->set($lockKey, $token, ['NX', 'EX' => 30]);
// 强互斥场景需评估 Redlock 或 ZooKeeper/数据库排他方案

常见误区

  • 以为主从架构锁一定可靠:异步复制下崩溃窗口仍会丢锁。
  • 把锁用在资金扣减等绝对排他场景却不评估该风险:需更强一致性方案。

追问

  • 集群模式同样有此问题吗?答:槽位主节点异步复制到副本,主宕机切换同样可能丢未同步的 key。
  • 风险窗口多大?答:取决于复制延迟与故障时刻,未连实例实测前不给出具体毫秒值,标注待确认。

06.5.8.3-009 Redlock 算法流程与争议点是什么?

一句话结论

Redlock 向多个独立 Redis 节点申请同一把锁,超过半数节点加锁成功且总耗时小于锁有效期才算获得锁;争议在于时钟跳变、网络延迟与节点故障假设,学术界与工程界对其安全性有不同看法。

概念解释

Redlock 假设部署 N 个(通常 5)独立主节点,不做主从复制。流程:记录开始时间,依次向各节点加锁(短超时),统计成功节点数;成功数 ≥ 多数(⌈N/2⌉+1)且总耗时未超过有效期,才算加锁成功;否则向所有节点释放锁。争议点:依赖各节点时钟近似同步,GC 停顿与网络延迟会侵蚀有效期,Martin Kleppmann 与 Antirez 曾有公开讨论。

原理流程

  1. 记录加锁开始时刻,依次向 N 个独立节点发 SET NX PX。
  2. 统计成功节点数与消耗时间。
  3. 成功数达多数且剩余有效期充足:持锁成功。
  4. 未达多数:向所有节点发送释放;持锁后到期前续期。

代码或图示

// 示意:多节点依次加锁,多数成功才认定持锁
// foreach ($nodes as $node) { $node->set($lockKey, $token, ['NX', 'PX' => 30000]); }
// $quorum = intdiv($nodeCount, 2) + 1;
// 成功节点数 >= $quorum 且耗时 < 有效期 => 成功;否则全员释放

常见误区

  • 把 Redlock 当成绝对强一致:它仍是基于时间与多数节点的概率方案,不是共识协议。
  • 节点间做主从复制来跑 Redlock:违背独立节点假设,故障域重叠。

追问

  • 时钟跳变影响什么?答:节点本地时间不一致会导致 TTL 判定偏差,锁提前或延后过期。
  • 工程上什么时候用?答:可容忍极小概率并发、且比数据库锁更轻的场景;强一致排他优先选共识型协调服务。

06.5.8.3-010 Redis 锁与数据库锁、ZooKeeper 锁如何取舍?

一句话结论

Redis 锁轻量高性能,适合短时、可容忍极小并发风险的临界区;数据库排他锁依托事务与行锁,可靠性高但吞吐低;ZooKeeper/etcd 基于共识与临时节点,一致性强但接入重。按一致性要求与性能取舍。

概念解释

Redis 锁性能好、实现简单,但有主从切换与超时风险;数据库 SELECT ... FOR UPDATE 随事务提交/回滚释放,依赖行锁与连接;协调服务用临时顺序节点 + Watch,会话断开自动释放,一致性由共识保证。选型先看业务能否接受偶发并发,再看性能与基础设施成本。

原理流程

  1. 明确临界区一致性要求:资金/库存强排他还是普通防重。
  2. 高并发短临界区:优先 Redis 锁,评估风险兜底。
  3. 强一致且量不大:用数据库行锁或乐观锁版本号。
  4. 已有共识设施且要求会话绑定释放:用协调服务临时节点。

代码或图示

// 数据库排他锁(随事务释放)
// $db->beginTransaction();
// $row = $db->query("SELECT * FROM stock WHERE sku = 'A1' FOR UPDATE")->fetch();
// ... 扣减 ...
// $db->commit();

常见误区

  • 所有并发控制都上 Redis 锁:强一致场景低估锁丢失风险。
  • 数据库锁用在高并发短事务外:行锁持有久,连接堆积。

追问

  • 乐观锁算分布式锁吗?答:不算排他锁,是版本号 CAS 冲突重试机制,适合冲突少的更新。
  • etcd 与 ZooKeeper 锁差异?答:都基于共识与临时节点,实现细节与客户端生态不同;本项目不引入额外中间件,仅作对比。

06.5.8.3-011 Redis 为什么能保证 Lua 脚本原子执行?

一句话结论

Redis 单线程事件循环串行执行命令,Lua 脚本作为一个整体在执行期间不会被其他客户端命令打断,因此脚本内多条命令具备原子性;脚本应保持短小,避免长时间阻塞。

概念解释

Redis 命令处理在主线程串行调度,Lua 脚本从开始执行到返回结果期间,其他连接的命令排队等待。这让脚本内的「判断 + 读写」成为原子操作。代价:脚本执行期间占用主线程,复杂循环或大集合操作会阻塞所有请求。

原理流程

  1. 客户端提交 Lua 脚本与 KEYS/ARGV 参数。
  2. Redis 在主线程顺序执行脚本内命令。
  3. 脚本执行期间其他客户端命令排队。
  4. 返回结果后才继续处理下一条命令。

代码或图示

// 短小脚本:读判断后删除,全程原子
$redis->eval(<<<'LUA'
if redis.call("GET", KEYS[1]) == ARGV[1] then
    return redis.call("DEL", KEYS[1])
end
return 0
LUA, [$lockKey, $token], 1);

常见误区

  • 在 Lua 里遍历大集合:阻塞主线程,其他请求超时。
  • 把业务编排塞进 Lua:调试困难,应用层应做业务判断,Lua 只做原子小动作。

追问

  • Lua 能调用哪些命令?答:脚本内用 redis.call/redis.pcall 执行 Redis 命令,参数来自 KEYS 与 ARGV。
  • 集群下 Lua 有什么限制?答:脚本涉及的 key 必须在同一槽位,否则报错;见限流与集群约束题。

06.5.8.3-012 加锁失败如何处理:自旋等待、快速失败还是排队?

一句话结论

按业务选择策略:防重复提交快速失败;可等待的短临界区有限次自旋重试;高排队需求用等待队列(ZSet)公平排队;无论哪种都要有等待上限与降级,避免请求堆积。

概念解释

加锁失败的语义是「资源被占用」。快速失败直接提示稍后再试,适合幂等提交;自旋是短间隔重试若干次,适合临界区极短;排队方案给等待者发序号,按序获锁,实现复杂但公平。PHP 请求线程不能无限挂起,所有策略都要设超时与次数上限。

原理流程

  1. 加锁失败先判断业务是否允许等待。
  2. 不允许:快速失败返回提示。
  3. 允许等待:有限次间隔重试,记录已等待时间。
  4. 超时仍未获锁:降级或失败,不无限阻塞。

代码或图示

for ($attempt = 0; $attempt < 3; $attempt++) {
    $ok = $redis->set($lockKey, $token, ['NX', 'EX' => 30]);
    if ($ok) { break; }
    usleep(80 * 1000);
}
if (!$ok) { throw new RuntimeException("系统繁忙,请稍后重试"); }

常见误区

  • 自旋无次数上限:请求挂住耗尽 FPM 进程。
  • 排队队列不设超时:等待者永久滞留,资源泄漏。

追问

  • 公平排队怎么实现?答:ZSet 存等待者序号与时间,持锁释放后唤醒队首;复杂度高,只在确有公平要求时做。
  • 自旋间隔怎么定?答:按临界区时长设短间隔,配合次数上限;具体值按压测定,未实测标注待确认。

06.5.8.3-013 锁内哪些操作会导致长持锁?

一句话结论

锁内做远程 HTTP 调用、外部 MQ 发送、慢数据库查询、文件处理或等待用户输入都会拉长持锁时间;临界区应只做内存计算与必要的短数据库操作,慢步骤移到锁外异步化。

概念解释

持锁期间其他竞争者全部等待,锁内任何慢操作都会放大排队。常见问题:锁内调用第三方接口、锁内批量查询、锁内发消息再等确认、循环处理大集合。治理:缩小临界区,把可异步的动作(发通知、写日志、推消息)放到释放锁之后。

原理流程

  1. 梳理临界区代码块,列出其中的外部调用与 IO。
  2. 区分必须在排他内完成的步骤与可后置的步骤。
  3. 后置步骤改为释放锁后执行或异步任务处理。
  4. 压测临界区耗时,设定 TTL 与等待上限。

代码或图示

// 反例:锁内发 MQ、调外部接口
// $redis->set($lockKey, $token, ['NX', 'EX' => 30]);
// $mq->publish(...); $http->post(...); // 持锁等待外部响应
// 正确:锁内只扣减状态,通知类操作锁后异步

常见误区

  • 把整个业务用例包进锁:锁粒度过粗且内含慢 IO。
  • 锁内同步等待 MQ 确认: broker 抖动直接拉长所有竞争者等待。

追问

  • 扣库存必须在锁内吗?答:库存扣减可由数据库行锁/乐观锁承担,Redis 锁只做防重入口;两种机制不要重复嵌套。
  • 怎么测持锁时长?答:记录加锁与释放时间戳差值,统计 P95 持锁时长,作为 TTL 与续期依据。

06.5.8.3-014 误删锁的场景与防护手段有哪些?

一句话结论

误删发生在:锁过期被他人重获后旧持锁者释放、释放命令未校验归属、多节点时钟或脚本错误;防护靠唯一 token + Lua 原子比对删除 + 合理 TTL + 续期校验。

概念解释

误删等于把别人的排他权解除,随后并发进入临界区。典型链条:A 业务慢于 TTL → 锁过期 → B 抢到锁 → A 结束执行删除命令。防护:value 唯一标识;删除用 Lua 比对;续期只认自己的锁;监控锁剩余时间与释放返回值。释放返回 0 说明锁已不归自己,记日志告警。

原理流程

  1. 加锁写入随机 token 作为归属凭证。
  2. 释放走 Lua:GET 比对,相等才 DEL。
  3. 续期同样比对 token,不归属不延长。
  4. 释放返回 0 或比对失败时记录告警,排查超时与误删。

代码或图示

$released = $redis->eval(<<<'LUA'
if redis.call("GET", KEYS[1]) == ARGV[1] then
    return redis.call("DEL", KEYS[1])
end
return 0
LUA, [$lockKey, $token], 1);
if ($released === 0) { /* 锁已不属于自己,记录告警 */ }

常见误区

  • 释放不看返回值:锁被他人持有也以为正常释放。
  • token 在多次请求间复用:归属判断失去唯一性。

追问

  • 超时后怎么知道锁丢了?答:续期脚本返回 0 即归属丢失,应用应停止临界区后续动作并告警。
  • 误删后能补救吗?答:难以及时补救,只能靠业务层幂等与数据库约束兜底并发后果。

06.5.8.3-015 基于 ZSet 的公平等待队列怎么实现?

一句话结论

需要公平排队时,申请者把自身标识与序号写入 ZSet(分数为申请序号或时间戳),持锁者释放后按分数最小唤醒队首;队首获得锁后移出等待集合,其余继续等待。

概念解释

普通自旋锁不保证先后顺序,后来者可能先抢到。ZSet 等待队列按申请顺序排序:入队取序号入 ZSet;当前持锁者释放后,队首元素尝试加锁,成功则移出队列;等待者通过轮询或订阅通知获取自身位次。实现复杂度高于自旋,只在公平性明确要求时采用。

原理流程

  1. 申请者生成标识与递增序号,ZADD queue <序号> <标识>。
  2. 尝试获取锁;未获得则在队列中等候。
  3. 持锁者释放后,取 ZRANGE queue 0 0 队首尝试加锁。
  4. 获锁成功移出等待集;超时未获锁出队并失败。

代码或图示

$queueKey = "lock:queue:order:{$orderId}";
$seq = $redis->incr("lock:seq:order:{$orderId}");
$redis->zAdd($queueKey, $seq, $token);
// 队首:ZRANGE queueKey 0 0 WITHSCORES
// 获锁成功:ZREM queueKey token

常见误区

  • 队列条目不清理:超时申请者残留,队首永远是失效节点。
  • 只排队不加锁:队列解决顺序,真正互斥仍要 Redis 锁或数据库约束。

追问

  • 等待通知怎么做?答:轮询位次最低成本;要实时唤醒可用发布订阅,但订阅断开要补轮询兜底。
  • 序号怎么保证递增?答:用 INCR 生成单调序号,单节点内递增即可满足排队顺序。

06.5.8.3-016 Redlock 场景下时钟跳变会造成什么问题?

一句话结论

Redlock 的 TTL 判定依赖各节点本地时间近似同步,节点时钟回拨或跳变会让有效期计算失真:锁提前过期被并发获取,或过期延迟释放,破坏多数派安全性。

概念解释

单节点锁的 TTL 由该节点单调计时;Redlock 在多个节点分别记录过期时间,客户端用总耗时判断剩余有效期。若某节点时钟回拨,本地过期判定偏慢;时钟向前跳变则过期偏快。时钟跳变还影响续期节奏。共识型协调服务(etcd/ZooKeeper)用逻辑时钟与共识规避此问题。

原理流程

  1. 多节点分别按本地时间写入带 PX 的锁 key。
  2. 客户端按各节点有效期估算可用剩余时间。
  3. 时钟跳变导致部分节点提前或延后过期。
  4. 多数派判定与实际锁状态偏离,互斥被突破。

代码或图示

// Redlock 有效性依赖节点时钟同步;部署应配置 NTP 时钟同步
// 待确认:当前环境节点部署与时钟同步状态,需运维核实

常见误区

  • 认为 Redlock 自动处理时钟差异:算法假设时钟近似一致,不做时钟校准。
  • 跳过 NTP 配置跑多节点:跳变风险无人监控。

追问

  • 怎么降低时钟风险?答:节点部署同一机房、配置 NTP 同步、监控时钟偏差;仍不能消除算法层面争议。
  • 还有哪些争议?答:网络分区下多数派可达性、GC 停顿占用有效期,均在公开讨论中;选型时按社区共识评估。

06.5.8.3-017 PHP 侧 Lua 脚本如何使用与缓存?

一句话结论

phpredis 用 eval 传脚本体执行,evalSha 传 SHA1 摘要;脚本常用时先 evalSha,命中服务端缓存则不重复传输脚本体,未命中回退 eval;KEYS 与 ARGV 分开传参,不拼接进脚本。

概念解释

eval 每次发送完整脚本,简单直接但带宽重复;evalSha 先发送摘要,服务端已缓存该脚本则直接执行,否则返回 NOSCRIPT 错误,客户端回退 eval 上传脚本体。脚本内 key 必须通过 KEYS 传入,参数通过 ARGV 传入,避免拼接字符串造成注入与集群槽位问题。

原理流程

  1. 编写固定 Lua 脚本,计算或直接用 eval 首次上传。
  2. 后续调用用 evalSha 传摘要与参数。
  3. 收到 NOSCRIPT 类错误回退 eval 重新缓存。
  4. KEYS 数组列出所有涉及 key,ARGV 传值。

代码或图示

$script = 'return redis.call("GET", KEYS[1])';
$sha = $redis->script("load", $script);
// 命中缓存用 evalSha;失败回退 eval
try {
    $result = $redis->evalSha($sha, [$lockKey], 1);
} catch (Throwable $e) {
    $result = $redis->eval($script, [$lockKey], 1);
}

常见误区

  • 把业务值拼进 Lua 字符串:转义不当带来注入风险,参数一律走 ARGV。
  • evalSha 失败不回退:脚本被服务端淘汰后调用直接报错。

追问

  • 脚本缓存什么时候失效?答:服务端重启或脚本被清理后需重新 load;客户端应实现回退逻辑。
  • phpredis 方法名以什么为准?答:以已装 redis 扩展版本文档为准;本环境 CLI 已装扩展,未连实例前方法签名细节标注待确认。

06.5.8.3-018 锁与幂等是什么关系,同一请求重复进入临界区怎么防护?

一句话结论

锁防并发同时进入,幂等防同一业务请求重复执行产生副作用;两者互补:入口用锁串行化,业务侧用唯一请求号/业务键去重,锁丢失或超时重试时仍不产生重复下单、重复扣款。

概念解释

分布式锁解决「同时」问题,重复提交解决「多次」问题。用户双击、网关重试、消息重投都会让同一业务执行多次。幂等手段:唯一请求流水号落去重表、数据库唯一索引、状态机校验(订单只能从待支付走到已支付)。即使锁失效并发进入,幂等约束挡住重复副作用。

原理流程

  1. 请求携带唯一业务键(订单号、请求流水号)。
  2. 入口加锁串行化同一资源。
  3. 业务执行前检查去重记录/状态机,已处理则直接返回结果。
  4. 处理成功落去重记录或更新状态,重复请求命中校验跳过。

代码或图示

// 幂等校验:唯一请求号落表,唯一索引防重复
// INSERT INTO idempotent(request_key, status) VALUES (?, 'done')
// 唯一索引冲突即说明已处理,直接返回上次结果
$redis->setnx("idem:{$requestKey}", "1");

常见误区

  • 以为加了锁就不用幂等:锁超时、重入、主从切换后重复执行仍会产生副作用。
  • 幂等键用可变字段(金额):同一业务不同次请求键变化,去重失效。

追问

  • 去重记录存哪里?答:强约束落数据库唯一索引;Redis 去重只做快速拦截,两者配合。
  • 幂等记录保留多久?答:覆盖业务重试与回调周期;过期清理策略按业务定。

06.5.8.3-019 死锁残留如何排查?

一句话结论

锁 key 长期不释放即残留,排查路径:扫描 lock: 前缀查看 TTL、剩余时间与 value;核对持锁请求是否崩溃;区分「无 TTL 死锁」「持锁超时未续期」「业务死等」三类成因分别处理。

概念解释

残留成因:早期代码 SETNX 后未设过期;持锁进程崩溃但 TTL 过长;续期任务挂掉;Lua 释放脚本异常。排查命令按前缀 SCAN,逐个 TTL 与 OBJECT ENCODING 查看;线上禁止 KEYS 全量扫描。确认残留后评估能否安全删除,删除前核对 value 归属。

原理流程

  1. SCAN 列出 lock: 前缀 key,统计数量与 TTL 分布。
  2. 对 TTL 为 -1(无过期)的 key 优先核查来源代码。
  3. 查看 value 对应节点/请求日志,判断是否崩溃残留。
  4. 确认无归属后删除;修复代码中的过期与释放路径。

代码或图示

// 扫描锁 key(不用 KEYS)
// SCAN cursor MATCH lock:* COUNT 100
// TTL lock:order:2001
// OBJECT ENCODING lock:order:2001

常见误区

  • 看到残留直接 DEL:未核对归属可能删掉正常持锁者。
  • 只删 key 不改代码:同类崩溃残留还会再产生。

追问

  • TTL 返回 -1 与 -2 含义?答:-1 无过期时间,-2 key 不存在;具体返回语义以 Redis 版本文档为准,待确认项实测核对。
  • 怎么监控锁残留?答:定期统计 lock 前缀 key 数量、无 TTL 占比,超过阈值告警。

06.5.8.3-020 什么场景不该用分布式锁?

一句话结论

短临界区、冲突极少、可由数据库唯一约束/乐观锁解决的场景不必上分布式锁;本地竞态用进程内手段即可;需要强一致的场景应选共识方案而非迷信 Redis 锁。锁是最后手段,先评估约束与无锁设计。

概念解释

引入分布式锁带来:超时风险、续期复杂度、锁残留排查、主从切换风险。很多并发问题有更合适的解法:唯一索引防重复、乐观锁版本号处理少冲突更新、数据库行锁处理事务内排他、状态机拒绝非法流转。只有真正需要跨进程互斥且一致性要求可接受时,才用 Redis 锁。

原理流程

  1. 先列并发冲突的具体表现与数据约束。
  2. 评估唯一索引、乐观锁、状态机、行锁能否覆盖。
  3. 确需跨节点互斥:再评估 Redis 锁的风险与兜底。
  4. 强一致排他:选择数据库或共识协调服务方案。

代码或图示

// 优先:数据库唯一索引防重复提交
// ALTER TABLE orders ADD UNIQUE INDEX uk_request (request_key);
// 乐观锁:UPDATE stock SET count = count - 1, version = version + 1
//        WHERE sku = ? AND version = ?; 影响行数 0 则重试

常见误区

  • 接口一有并发就加锁:把无锁能解决的问题串行化,性能损失大。
  • Redis 锁用于资金扣减却不评估主从风险:应优先数据库事务与约束。

追问

  • 本地进程内竞态用什么?答:FPM 多进程模型下本地互斥只在单进程内有效,跨进程共享状态仍要靠外部存储。
  • 无锁设计怎么减少冲突?答:按资源分片、队列串行化同一资源、减小事务粒度,从架构上降低争用。