订单服务部署了 3 个实例,同一时刻两个实例都在处理同一笔请求——Java 的 synchronized 只锁得住单机,跨进程就要分布式锁(多实例共用的互斥锁,通常落在 Redis 或 ZooKeeper 上)。这篇从裸写 SETNX 一路进化到 Redisson,看每一步补的是什么洞。
// 坑1:setnx 和 expire 两条命令不原子 → setnx后宕机,死锁
redis.setIfAbsent(lockKey, "1");
redis.expire(lockKey, 10, SECONDS);
// 修复:合并成一条原子命令
redis.setIfAbsent(lockKey, clientId, 10, SECONDS);
// 坑2:删锁不验身份 → 超时后删掉了别人刚加的锁
if ("1".equals(redis.get(lockKey))) redis.delete(lockKey);
// 修复:值存唯一标识,删前比对
if (clientId.equals(redis.get(lockKey))) redis.delete(lockKey);
// 坑3:比对和删除仍是两步 → 比完刚好过期,又删错
// 终极修复:Lua 脚本让「比对+删除」原子执行
裸写能走到这已经很累,但还有第四个坑:业务没跑完锁先过期了。别再造轮子了,上 Redisson。
Redisson(基于 Redis 的 Java 驻留对象框架,分布式锁是它的招牌菜)加锁用一段 Lua 脚本,天然原子:
if redis.call('exists', KEYS[1]) == 0 then
redis.call('hset', KEYS[1], ARGV[2], 1) -- Hash结构: {线程标识:1}
redis.call('pexpire', KEYS[1], ARGV[1]) -- 设过期时间
return nil
end
if redis.call('hexists', KEYS[1], ARGV[2]) == 1 then
redis.call('hincrby', KEYS[1], ARGV[2], 1) -- 是自己: 重入计数+1
redis.call('pexpire', KEYS[1], ARGV[1])
return nil
end
return redis.call('pttl', KEYS[1]) -- 别人的锁, 返回剩余时间
两个设计点:锁是 Hash 结构,field 存线程标识、value 存重入次数——同线程再来一次计数加一,可重入免费拿到;解锁也是 Lua,先验 field 是自己才删,计数减到零才真删。
看门狗(后台定时给锁续期的机制)专治「业务没跑完锁先过期」:
加锁成功(默认30秒)
→ 启动定时任务,每 10 秒(= 30秒/3)把锁续回 30 秒
→ 业务执行完 unlock,看门狗取消
→ 实例宕机,看门狗跟着死 → 30 秒后锁自动释放,不致死锁
最大的坑在参数上:
lock.tryLock(5, 30, TimeUnit.SECONDS); // 指定leaseTime=30 → 看门狗不启动!
lock.tryLock(5, TimeUnit.SECONDS); // 不指定 → 看门狗生效,自动续期
指定了 leaseTime,Redisson 认为你自己管理过期,看门狗直接不启动。线上很多「锁莫名失效」的事故,根因就是手贱传了第二个参数。
把两个重载的参数语义读透:tryLock(waitTime, leaseTime, unit) 是「最多等锁 waitTime 秒,拿到后 leaseTime 秒强制过期,不续期」;tryLock(waitTime, unit) 是「最多等锁 waitTime 秒,拿到后看门狗接管,业务没跑完就一直续」。前者适合「执行时间可精确预估」的任务(定时 job),后者适合「执行时间不可控」的业务请求——选错轻则锁提前释放出并发事故,重则业务中断锁迟迟不释放。
getLock 之外还有几个常用货:读写锁 RReadWriteLock——读读共享、读写互斥,缓存重建这类读多写少场景吞吐高一大截;公平锁 RFairLock——按申请顺序排队,饿不着但吞吐降;联锁 RLock 的 MultiLock——把多把锁捆成一把,全拿到才算成功;红锁 RedLock——MultiLock 的特例,锁分散在多个独立实例上,过半成功即持有。家族成员按场景挑,别一把 getLock 走天下。
RLock lock = redissonClient.getLock("lock:order:" + productId);
try {
boolean ok = lock.tryLock(5, TimeUnit.SECONDS); // 最多等5秒,看门狗续期
if (!ok) throw new BizException("系统繁忙,请稍后重试");
return doCreateOrder(productId); // 临界区
} finally {
if (lock.isHeldByCurrentThread()) lock.unlock(); // 只解自己的锁
}
主从复制是异步的:客户端 A 在主库加锁成功、主库还没同步就宕机,从库转正后没有这把锁——客户端 B 又加锁成功,两把锁并存。
RedLock 算法(向 5 个独立 Redis 实例依次加锁、过半成功才算持有的方案)试图解决:多数派存活即锁有效。但学界有著名批评(Martin Kleppmann):时钟跳跃或 GC 停顿会让持有者误判自己还持有锁,建议加 Fencing 令牌(每次加锁递增的序号,存储端拒绝旧序号的写)兜底。作者 antirez 反驳时钟问题部署可控。工程共识:非金融场景单实例 Redisson 加数据库唯一索引兜底足够;金融强一致用 ZooKeeper 临时顺序节点(天然防死锁 + 公平锁,性能低一档)。
ZooKeeper 方案展开一句:加锁就是创建临时顺序节点 /lock/seq-001,看自己是不是当前最小序号——是则持有,不是则监听前一个节点;前驱释放(会话断开临时节点自动删)就轮到自己。会话断线节点自动消失,防死锁是结构自带的,不像 Redis 要靠过期时间赌。代价是所有写操作走 ZAB 共识协议落盘,吞吐比纯内存的 Redis 低一个量级——选它还是选 Redisson,本质是「一致性权重 vs 性能权重」的取舍题。
还有一道高频追问:「锁要不要和数据库兜底配合?」要。分布式锁是性能层的拦截,唯一索引是正确性的最后防线——锁偶尔失效时,数据库层把重复动作拦下来,两层一起才睡得踏实。
面试有时要求现场手写,浓缩版长这样:
String id = UUID.randomUUID().toString(); // 锁的身份
if (redis.setIfAbsent(key, id, 10, SECONDS)) { // 原子加锁+过期
try {
doBusiness(); // 临界区
} finally {
unlockByLua(key, id); // Lua验证身份再删
}
}
加锁一行(setIfAbsent 自带过期)、解锁一段 Lua(验身份 + 删除原子执行)——写出这两点手写题就及格;再补一句「生产用 Redisson,看门管续期」,就是满分答案的形态。手写的价值不在上线,在于证明你懂每个部件防的是什么。
再补一道高频追问「拿不到锁怎么办」的三种姿势:直接报错让用户稍后重试,适合页面请求这类体验优先的场景;有限自旋再试几次,适合低并发的内部任务;投递 MQ 排队异步处理,适合秒杀这类要削峰的场景。拒绝策略同样是设计的一部分,不是异常分支的边角料。
「锁订单为什么用 lock:order:{id} 而不是 lock:order?」——前者锁单笔订单互不干扰,后者全局串行,吞吐差几个量级。粒度越细并发越高,但两个代价随之而来:锁数量爆炸难管理;跨多锁的组合操作(转账锁两个账户)要按固定顺序加锁防死锁——和 9.5 的结论一模一样。一句话:锁粒度对齐业务的最小互斥单元,多锁操作对齐固定顺序。
分布式锁的进化史就是填坑史:命令合一、Lua 原子、Hash 可重入、看门狗续期——Redisson 把前四坑全填了,剩下的「主从丢锁」按业务容忍度选 RedLock 或 ZooKeeper。