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 原子完成两件事。
原理流程
- 生成锁的唯一标识值(随机串或实例 + 线程标识)。
- 执行
SET lock:<资源> <唯一值> NX EX <超时秒>。 - 返回成功即获得锁;返回 nil 表示已被持有。
- 临界区执行完,按唯一值安全释放锁。
代码或图示
$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,前一个持锁者会删掉新持锁者的锁。唯一标识(随机串 + 节点/线程信息)让每次加锁可区分,释放时只删自己的锁。
原理流程
- 加锁时生成全局唯一 token,写入锁 value。
- 临界区结束准备释放。
- 读取 value 与本地 token 比对,一致才删除。
- 比对与删除必须用 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 → 相等则删 → 返回结果」,期间不穿插其他客户端命令。
原理流程
- 把锁 key 与 token 传给 Lua 脚本。
- 脚本读取 key 对应 value。
- value 等于 token:删除 key,返回 1;不等返回 0。
- 客户端按返回值判断锁是否由自己释放。
代码或图示
$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,归零删除。
原理流程
- 首次加锁:
HSET lock owner <token> count 1,设 TTL。 - 重入:判断 owner 是本 token,
HINCRBY count 1。 - 退出一层:
HINCRBY count -1,count 为 0 删除 key。 - 全程用 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 的环境不要假设协程后台。
原理流程
- 加锁时设定初始过期时间(如 30 秒)。
- 后台续期任务在到期前 1/3 周期检查锁仍归本 token。
- 归属一致:执行
EXPIRE延长;归属丢失:停止续期。 - 临界区退出后关闭续期任务,删除锁。
代码或图示
// 续期 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,便于排查与批量管理。
原理流程
- 找出临界区需要排他的资源实体与标识。
- 以资源 ID 组装锁 key,如
lock:stock:{skuId}。 - 评估临界区是否跨多个资源,跨资源时考虑顺序加锁避免死锁。
- 复盘锁竞争度,过粗则细化,过细则评估批量合并。
代码或图示
// 订单级锁:只互斥同一订单的并发操作
$lockKey = "lock:order:{$orderId}";
// 反例:全局锁 lock:submit,所有下单请求串行
常见误区
- 用方法名当锁 key:同一方法操作不同资源也被互斥,并发度被无谓拉低。
- 锁粒度细到每条记录却在锁内做远程调用:持锁时间长,细粒度收益被抵消。
追问
- 一次操作锁多个资源怎么办?答:按固定顺序加锁(如按 ID 升序),避免交叉持有形成死锁。
- 锁 key 命名规范?答:
lock:<业务>:<资源类型>:<标识>,与普通缓存 key 前缀区分。
06.5.8.3-007 持锁进程崩溃后锁如何释放?
一句话结论
依赖锁的 TTL 过期自动释放:持锁者异常退出不会执行释放,key 到期后其他节点可重新获取;TTL 是崩溃场景的唯一兜底,因此不能省略。
概念解释
分布式锁没有进程内的析构保证,持锁节点断电、进程被杀、网络断开都不会走到释放逻辑。服务端按过期时间淘汰 key,其余请求在到期后抢锁。TTL 取值要平衡:过短误释放正常业务,过长崩溃后阻塞等待久。
原理流程
- 加锁时写入 EX/PX 过期时间。
- 持锁者正常退出:主动比对删除。
- 持锁者崩溃:不执行删除,等待 TTL 到期服务端回收。
- 到期后其他节点重试加锁成功进入临界区。
代码或图示
// 崩溃兜底: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。业务侧以为持锁成功,实际新主允许重复加锁。风险窗口很小但在强互斥场景不可忽略。
原理流程
- 客户端在主节点加锁成功,收到返回。
- 锁 key 异步复制到从节点,存在传输延迟。
- 主节点在复制完成前故障,从节点提升为新主。
- 新主无锁记录,另一客户端加锁成功,临界区被并发进入。
代码或图示
// 主从切换风险示意:加锁返回成功不等于锁已持久化到多数节点
// $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 曾有公开讨论。
原理流程
- 记录加锁开始时刻,依次向 N 个独立节点发
SET NX PX。 - 统计成功节点数与消耗时间。
- 成功数达多数且剩余有效期充足:持锁成功。
- 未达多数:向所有节点发送释放;持锁后到期前续期。
代码或图示
// 示意:多节点依次加锁,多数成功才认定持锁
// 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,会话断开自动释放,一致性由共识保证。选型先看业务能否接受偶发并发,再看性能与基础设施成本。
原理流程
- 明确临界区一致性要求:资金/库存强排他还是普通防重。
- 高并发短临界区:优先 Redis 锁,评估风险兜底。
- 强一致且量不大:用数据库行锁或乐观锁版本号。
- 已有共识设施且要求会话绑定释放:用协调服务临时节点。
代码或图示
// 数据库排他锁(随事务释放)
// $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 脚本从开始执行到返回结果期间,其他连接的命令排队等待。这让脚本内的「判断 + 读写」成为原子操作。代价:脚本执行期间占用主线程,复杂循环或大集合操作会阻塞所有请求。
原理流程
- 客户端提交 Lua 脚本与 KEYS/ARGV 参数。
- Redis 在主线程顺序执行脚本内命令。
- 脚本执行期间其他客户端命令排队。
- 返回结果后才继续处理下一条命令。
代码或图示
// 短小脚本:读判断后删除,全程原子
$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 请求线程不能无限挂起,所有策略都要设超时与次数上限。
原理流程
- 加锁失败先判断业务是否允许等待。
- 不允许:快速失败返回提示。
- 允许等待:有限次间隔重试,记录已等待时间。
- 超时仍未获锁:降级或失败,不无限阻塞。
代码或图示
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 发送、慢数据库查询、文件处理或等待用户输入都会拉长持锁时间;临界区应只做内存计算与必要的短数据库操作,慢步骤移到锁外异步化。
概念解释
持锁期间其他竞争者全部等待,锁内任何慢操作都会放大排队。常见问题:锁内调用第三方接口、锁内批量查询、锁内发消息再等确认、循环处理大集合。治理:缩小临界区,把可异步的动作(发通知、写日志、推消息)放到释放锁之后。
原理流程
- 梳理临界区代码块,列出其中的外部调用与 IO。
- 区分必须在排他内完成的步骤与可后置的步骤。
- 后置步骤改为释放锁后执行或异步任务处理。
- 压测临界区耗时,设定 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 说明锁已不归自己,记日志告警。
原理流程
- 加锁写入随机 token 作为归属凭证。
- 释放走 Lua:GET 比对,相等才 DEL。
- 续期同样比对 token,不归属不延长。
- 释放返回 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;当前持锁者释放后,队首元素尝试加锁,成功则移出队列;等待者通过轮询或订阅通知获取自身位次。实现复杂度高于自旋,只在公平性明确要求时采用。
原理流程
- 申请者生成标识与递增序号,
ZADD queue <序号> <标识>。 - 尝试获取锁;未获得则在队列中等候。
- 持锁者释放后,取
ZRANGE queue 0 0队首尝试加锁。 - 获锁成功移出等待集;超时未获锁出队并失败。
代码或图示
$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)用逻辑时钟与共识规避此问题。
原理流程
- 多节点分别按本地时间写入带 PX 的锁 key。
- 客户端按各节点有效期估算可用剩余时间。
- 时钟跳变导致部分节点提前或延后过期。
- 多数派判定与实际锁状态偏离,互斥被突破。
代码或图示
// 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 传入,避免拼接字符串造成注入与集群槽位问题。
原理流程
- 编写固定 Lua 脚本,计算或直接用 eval 首次上传。
- 后续调用用 evalSha 传摘要与参数。
- 收到 NOSCRIPT 类错误回退 eval 重新缓存。
- 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 锁与幂等是什么关系,同一请求重复进入临界区怎么防护?
一句话结论
锁防并发同时进入,幂等防同一业务请求重复执行产生副作用;两者互补:入口用锁串行化,业务侧用唯一请求号/业务键去重,锁丢失或超时重试时仍不产生重复下单、重复扣款。
概念解释
分布式锁解决「同时」问题,重复提交解决「多次」问题。用户双击、网关重试、消息重投都会让同一业务执行多次。幂等手段:唯一请求流水号落去重表、数据库唯一索引、状态机校验(订单只能从待支付走到已支付)。即使锁失效并发进入,幂等约束挡住重复副作用。
原理流程
- 请求携带唯一业务键(订单号、请求流水号)。
- 入口加锁串行化同一资源。
- 业务执行前检查去重记录/状态机,已处理则直接返回结果。
- 处理成功落去重记录或更新状态,重复请求命中校验跳过。
代码或图示
// 幂等校验:唯一请求号落表,唯一索引防重复
// 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 归属。
原理流程
- SCAN 列出
lock:前缀 key,统计数量与 TTL 分布。 - 对 TTL 为 -1(无过期)的 key 优先核查来源代码。
- 查看 value 对应节点/请求日志,判断是否崩溃残留。
- 确认无归属后删除;修复代码中的过期与释放路径。
代码或图示
// 扫描锁 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 锁。
原理流程
- 先列并发冲突的具体表现与数据约束。
- 评估唯一索引、乐观锁、状态机、行锁能否覆盖。
- 确需跨节点互斥:再评估 Redis 锁的风险与兜底。
- 强一致排他:选择数据库或共识协调服务方案。
代码或图示
// 优先:数据库唯一索引防重复提交
// 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 多进程模型下本地互斥只在单进程内有效,跨进程共享状态仍要靠外部存储。
- 无锁设计怎么减少冲突?答:按资源分片、队列串行化同一资源、减小事务粒度,从架构上降低争用。