显式传 leaseTime 的那一刻,看门狗就被你关掉了

引言

一笔订单重复发货了 837 单。排查了三轮,最后定位到一行加锁代码:

RLock lock = redisson.getLock("lock:order:" + orderId);
lock.lock(30, TimeUnit.SECONDS);      // 显式指定 30 秒
try {
    doShip(orderId);                   // 实际耗时 47 秒(调用了物流接口)
} finally {
    lock.unlock();
}

代码没错,finally 也写了。问题是 lock(30, TimeUnit.SECONDS) 这个重载把看门狗关掉了:30 秒到了,Redisson 不管业务跑没跑完,锁就自动释放;第二个消费线程拿到锁,又发了一次货。

先给结论:Redisson 的看门狗不是"默认就有"的开关,而是一个"你没有指定过期时间"时才生效的兜底机制。一旦你显式传了 leaseTime,续期逻辑根本不会被注册。

一、先把参数搞清楚:哪个重载才带看门狗

RLock 的加锁入口最终都落到 tryLock(waitTime, leaseTime, unit),两个参数含义完全不同:

  • waitTime:最多等多久去抢锁,抢不到就返回 false(或按 lock() 语义一直等)
  • leaseTime:拿到锁后多久自动释放

看门狗的触发条件只有一条:leaseTime == -1。

调用方式waitTimeleaseTime看门狗超时后的行为
lock()-1(一直等)-1启用每 10 秒续期,直到解锁
lock(30, SECONDS)-130s关闭30 秒后强制释放
tryLock()0-1启用抢不到立即返回 false
tryLock(5, SECONDS)5s-1启用等 5 秒,抢不到返回 false
tryLock(5, 30, SECONDS)5s30s关闭30 秒后强制释放

表里第 2 行和第 5 行就是事故代码。"我传了时间,是不是更安全"——恰好相反,传了时间等于把自动续期的保险丝拆了。

waitTime 也不是"等待时间越长越安全":lock() 等价于 waitTime = -1,会一直阻塞到拿到锁,线程池里这么写,等待的线程会一直占着池子;tryLock(0, ...) 抢不到立刻返回 false,把"要不要重试"交回业务。选哪个不取决于"想等多久",取决于"等不到时业务能不能降级"。

二、加锁那一步:一个 Hash 同时表达归属和重入

tryLockInnerAsync 里跑的是一段 Lua:

-- KEYS[1] = lock:order:123   ARGV[1] = leaseTime(ms)   ARGV[2] = UUID:threadId
if (redis.call('exists', KEYS[1]) == 0)
  or (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;                                   -- nil 表示加锁成功
end;
return redis.call('pttl', KEYS[1]);               -- 返回剩余毫秒数,表示失败

锁在 Redis 里是一个 Hash:key 是 lock:order:123,field 是 UUID:threadId,value 是重入次数,TTL 挂在 key 上,默认 30 秒。

用 Hash 而不是 String,一次解决了三件事:谁能释放(field 精确到线程)、重入几次(value 累加)、什么时候过期(key 的 TTL)。用 String 的话,重入就得再开一个 key,原子性立刻没了——两次 INCR 和一次 EXPIRE 之间只要有一个失败,锁的状态就自相矛盾。

UUID:threadId 这个 field 有两个讲究:UUID 是客户端实例级别的,不是进程或 IP;线程 ID 是同一实例内的。所以两个 JVM 里恰好都是 42 号线程,也不会互相认成锁的持有者。

这个格式不是一开始就这样的。Redisson 2.x 时代的 field 只有线程 ID,导致"两个客户端、同一个线程 ID"会互相认错,后来才补上 UUID 前缀。这也解释了为什么排查旧代码时,HGETALL 出来看到的 field 形状不一样——不要拿两种格式的日志对比,会得出错误结论。

三、看门狗:每 10 秒续一次,靠的是定时任务

3.1 续期任务的注册

加锁成功后,如果 leaseTime == -1,RedissonLock 会调 scheduleExpirationRenewal(threadId),把当前锁登记进一个全局的 EXPIRATION_RENEWAL_MAP(key 是锁名),然后用 Netty 的 HashedWheelTimer 注册一个定时任务:

private void renewExpiration() {
    ExpirationEntry ee = EXPIRATION_RENEWAL_MAP.get(getEntryName());
    if (ee == null) return;
    Timeout task = commandExecutor.getConnectionManager().getTimer()
        .newTimeout(timeout -> {
            // 每 internalLockLeaseTime / 3 执行一次,默认 30s / 3 = 10s
            renewExpirationAsync(threadId).whenComplete((res, e) -> {
                if (res) {
                    renewExpiration();          // 续期成功,重新注册下一轮
                } else {
                    cancelExpirationRenewal(null);
                }
            });
        }, internalLockLeaseTime / 3);
    ee.setTimeout(task);
}

间隔是 30 秒的三分之一,也就是 10 秒。 为什么不是 29 秒——要留两次重试的机会:如果某次续期因为网络抖动失败,还有 20 秒和 10 秒两个窗口可以补上,而不是卡在"差 1 秒过期"的悬崖上。

调度用的是 Netty 的 HashedWheelTimer(时间轮),不是 ScheduledExecutorService。时间轮的优势在于"几万个定时任务也只用一个线程,且插入/取消是 O(1)"——分布式锁的续期任务可能同时存在成千上万个,ScheduledExecutorService 的优先队列在这点上会吃 CPU。代价是这个单线程必须足够可靠:它一旦被阻塞,所有锁的续期都会一起延迟。

3.2 续期脚本

-- KEYS[1] = 锁名   ARGV[1] = leaseTime   ARGV[2] = UUID:threadId
if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then
    redis.call('pexpire', KEYS[1], ARGV[1]);
    return 1;
end;
return 0;

续期不是无脑 pexpire,而是先 hexists 判断"这个线程还持有锁吗"。如果锁已经被别人拿走(比如发生过主从切换、或者业务自己误删),续期会返回 0,然后取消定时任务——避免去续一个不属于自己的锁。

3.3 解锁与取消续期

unlock 走另一段 Lua:hincrby -1,计数仍大于 0 就刷新 TTL 返回 0(表示还有重入),计数归零则 del 锁并 publish 一条解锁消息,唤醒等待者。随后 cancelExpirationRenewal(threadId) 把定时任务从 EXPIRATION_RENEWAL_MAP 里摘掉。

这一步很关键:如果不取消续期,锁释放后定时任务还会继续跑,去续一个已经不存在的 key。 Redisson 靠 ExpirationEntry 里的 threadId 引用计数来处理"同一线程重入多次、只取消最后一次"。

publish 那一步常被忽略:Redisson 的等待不是轮询,而是订阅 redisson_lock__channel:{lockName},解锁时发一条消息,所有等待者被唤醒后重新抢锁。这比"每 100ms 试一次"省了大量 Redis QPS——100 个等待者轮询,就是每秒 1,000 次无效请求。

四、设计哲学:为什么把过期时间交给持有者

如果让调用方"预估一个足够长的 leaseTime",会遇到两个无解的问题:估短了,业务超时导致锁提前释放(就是开头那 837 单);估长了,持锁进程崩溃后,其他线程要等到天荒地老。

看门狗把这个矛盾拆开了:leaseTime 固定 30 秒(足够短,崩溃后最多卡 30 秒),由"还活着的持有者"不断续期(足够长,业务跑多久都行)。

这个设计有三个隐含前提,缺一不可:

前提一:续期线程和业务线程在同一个 JVM 里。 进程挂了,续期自然停,锁在 30 秒内自动过期——不会死锁,这是它比"手动 expire 一个超长 TTL`"优雅的地方。

前提二:Redis 的时钟和续期任务都得靠得住。 续期是客户端发命令,不是 Redis 自己续。所以客户端到 Redis 的网络一旦断了,续期失败,锁照样会过期。

前提三:业务线程卡住时,续期线程还活着。 这是最危险的一种情况——见下一章。

30 秒这个默认值也不是随便选的:它要短于大多数"故障发现 + 人工介入"的时间(出了事 30 秒内锁会自动放开),又要长于绝大多数"正常业务耗时"的三倍(这样才有 10 秒的续期窗口)。如果业务 P99 是 60 秒,用默认的 30 秒也没关系——看门狗会一直续,它的作用是"保底",不是"上限"。

反过来,如果业务只要 50 毫秒,30 秒的 TTL 就显得"太宽容":进程崩溃后,这把锁要占着 30 秒,其他人才能进来。所以 TTL 的选择标准是"故障恢复的可接受时间",而不是"业务要跑多久"——业务跑多久是看门狗的事,恢复多快是你的事。

五、边界与避坑:看门狗保的是"进程活着",不是"业务正确"

长时间 Full GC 是看门狗的盲区。 业务线程被 STW 暂停 60 秒,但定时任务跑在 Netty 的 IO 线程上(也可能被一起暂停,也可能没有),续期可能照常进行。结果是:锁被一个"实际干不了活"的线程一直续着,其他线程全部阻塞。这不是死锁,是活锁,监控上表现为"锁等待时间无限增长、Redis 里那个 key 的 TTL 一直是 30 秒"。

活锁比死锁更难发现:死锁会报超时,活锁只会表现为"接口变慢",而且慢得很有规律——每次都是卡在拿锁那一步。判断方法很直接:PTTL 一直是 28~30 秒且长时间不变,就说明有人在续期,而那个"人"很可能已经干不了活了。

主从切换会丢锁。 Redis 主从是异步复制,主库写完锁、还没同步到从库就挂了,从库升主之后锁不存在,两个客户端同时持锁。Redisson 的 RedLock(多主)能降低概率,但 Martin Kleppmann 和 antirez 那场争论的结论是:它解决不了"时钟漂移 + 进程暂停"的组合。 对一致性要求极高的场景(比如扣款),分布式锁只能当"减少冲突",最终一致性还得靠数据库唯一索引或状态机兜底。

[配图:主库写入锁成功、复制未完成即宕机,从库升主后锁消失,两个客户端同时进入临界区]

真正工程化的补法是 fencing token:锁服务在每次成功加锁时返回一个单调递增的序号,写操作带着这个序号落库,数据库拒绝序号回退的写入。这样即使两个客户端同时"持锁",也只有序号更大的一方写成功。锁用来减少冲突,token 用来保证正确性,两者分工不同。

显式 leaseTime 是最常见的自伤。 如果业务确实需要一个上限(比如"最多允许处理 10 分钟"),正确做法是 lock() 用看门狗 + 业务侧加超时控制,而不是靠 lock(600, SECONDS) 把锁当定时器用。锁的过期时间是"故障恢复"参数,不是"业务超时"参数,这两个概念混在一起,就会出开头那种事故。

避坑清单:

  • lock(leaseTime) 会关掉看门狗,业务耗时不可预知时不要传这个参数。
  • 默认用 lock() 或 tryLock(waitTime),续期交给看门狗,超时控制写在业务里。
  • unlock 放 finally,并先判断 isHeldByCurrentThread(),否则会抛 IllegalMonitorStateException 或误删别人的锁。
  • 监控 PTTL 和锁等待时间,TTL 恒定 30 秒且等待队列变长,就是活锁信号。
  • 主从切换后不要假设锁还在,评估 RedLock 或带 fencing token 的方案。
  • 锁不能替代幂等,重复发货那 837 单,最终是靠对账和补数据收口的。
  • leaseTime 的语义是"故障恢复时间",不是"业务处理上限",这两个概念一混就会出事。

收尾

看门狗的本质是"把过期时间的所有权从调用方手里拿走,交给还活着的持有者"——它保证的是"进程死了锁会释放",从不保证"进程活着业务就对"。

你们的加锁代码里有没有显式传 leaseTime?有没有见过 TTL 一直不变、等待队列越来越长的情况?

关注我,每周拆一个真实生产故障。


标题:显式传 leaseTime 的那一刻,看门狗就被你关掉了
作者:jiangyi
地址:http://jiangyi.space/articles/2026/11/09/1794146525628.html
公众号:服务端技术精选
    评论
    0 评论
avatar

取消