fix(task-lock): 持锁封顶改按模块分档,两根平线都实测砍到过合法大单

30 分钟那版在主机A 留下 12 条 heldMs≈1,800,011 的精确撞线,被掐的 31725/31888
照常推进、最终在 43.7/49.3/49.8 分钟正常放过;改成一根 2 小时平线又会去砍
appearance-patent——两台 7 天日志的「放过」分布:similar-asin 7845 次最长 105.9 分,
appearance-patent 660 次最长 453.8 分(对应任务墙钟 9.4 小时、SUCCESS),
collect-data 1079 次最长 9.2 分。

现按模块分档(默认 2h/similar-asin 4h/appearance-patent 12h),6×TTL 项不变;
分档表整表只有一个出处,用例既钉静态线也钉「续期按这把锁的模块查线」的形状。
This commit is contained in:
2026-10-22 17:24:47 +08:00
parent 9c07b28a94
commit 16643f6912
2 changed files with 145 additions and 20 deletions
@@ -34,17 +34,49 @@ public class TaskDistributedLockService {
private static final long HELD_REPORT_MILLIS = 5000L;
private static final long HELD_WARN_MILLIS = 60000L;
/**
* 持锁封顶=max(30 分钟, 6×TTL)。越过这条线还续着期,说明持有方已经卡死而不是在干活:
* 封顶=max(本模块的下限, 6×TTL)。越过这条线还续着期,说明持有方已经卡死而不是在干活:
* 现网实测三把 {@code task:similar-asin:*} 被看门狗喂到 11.3 小时不放,期间该任务的
* 每一次结果回传都判 40902(两小时窗口 2370 次),任务永远停在 RUNNING。
* 到线后停止续期、让 Redis 键在 TTL 内自然过期,把"永久焊死"降级成"最多卡 TTL 量级"。
* 到线后停止续期、让 Redis 键在 TTL 内自然过期,把"永久焊死"降级成"最多卡到线 + TTL"。
*
* <p><b>下限按模块分档,是 10-22 拿两台 7 天容器日志的「放过」分布校准的</b>
* (判据只用 {@code [task-lock-held]}=真跑完并释放的那些,不用在持读数——后者按定义
* 包含还没放的活)。合法持锁时长在两个模块上差 5 倍,一根平线必顾此失彼:
* <ul>
* <li>{@code similar-asin}:7845 次放过,最长 <b>105.9 分钟</b>(主机A);
* 新代码上线后 2 小时窗口内 46 次放过最长 49.8 分钟。取 4 小时=约 2.3 倍余量。</li>
* <li>{@code appearance-patent}:660 次放过,最长 <b>453.8 分钟(7.6 小时)</b>(主机B),
* 且对应任务墙钟 9.4 小时、状态 SUCCESS——它的大单本来就要跑一整夜。取 12 小时。</li>
* <li>其余(collect-data 最长 9.2 分钟、brand/publish/price-track 都在 0.1 分钟量级):
* 走默认 2 小时。</li>
* </ul>
*
* <p><b>为什么不是一根线</b>:封顶第一版取 30 分钟,主机A 12 条 {@code 持锁超过上限}
* 全部 {@code heldMs≈1,800,011} 精确撞线,而被掐的 31725/31888 之后照常推进、最终在
* 43.7/49.3/49.8 分钟正常放过——那是把"慢但活着"当"卡死"治。第二版若直接抬成一根 2 小时线,
* 同一条线又会去砍 appearance-patent 那种 7.6 小时的合法单。
* 分布与探针记录见 ops 仓 {@code docs/audit/BACKLOG.md} 的 B15「封顶分档」一节;
* 要动这几条线,先拿同一把尺子重跑一遍再说。
*/
private static final long MAX_HOLD_FLOOR_MILLIS = 30 * 60_000L;
private static final int MAX_HOLD_TTL_MULTIPLE = 6;
/** 默认档在分档表里的键(真实模块名经 {@link #normalizedModule} 归一化后不会等于它)。 */
static final String DEFAULT_FLOOR_KEY = "default";
/**
* 分档表:键=归一化模块名,{@value #DEFAULT_FLOOR_KEY}=没有单独档时走的默认线。
* 整表只有这一个出处,用例也从这里取数比对,不允许判据与线各算各的。
*/
private static final Map<String, Long> MAX_HOLD_FLOOR_MILLIS = Map.of(
DEFAULT_FLOOR_KEY, 2 * 60 * 60_000L,
"similar-asin", 4 * 60 * 60_000L,
"appearance-patent", 12 * 60 * 60_000L);
private final DistributedJobLockService distributedJobLockService;
/** 持锁封顶的下限线,见 {@link #MAX_HOLD_FLOOR_MILLIS};测试会临时压低它来走封顶分支。 */
private volatile long maxHoldFloorMillis = MAX_HOLD_FLOOR_MILLIS;
/**
* 在持锁的分档线。生产恒等于 {@link #MAX_HOLD_FLOOR_MILLIS};测试接缝整表替换,
* 才能在毫秒级同时走到「这一档越界、那一档还在界内」那条分支。
* 不给它配成运行期参数:可调就会被人调花,而这三条线的依据是现网分布,不是偏好。
*/
private volatile Map<String, Long> maxHoldFloorsMillis = MAX_HOLD_FLOOR_MILLIS;
/**
* 取锁线程 → 该线程在持的锁。它只负责**重入判定**(同一线程再次取同一把锁不能把自己挡住),
* 释放一律走 {@link LockHandle} 上直接绑定的 {@link HeldLock}:早先 release 也按这张表找,
@@ -85,6 +117,7 @@ public class TaskDistributedLockService {
if (lockName == null) {
return null;
}
String module = normalizedModule(moduleType);
Map<String, HeldLock> heldLocks = localLocks.get();
HeldLock heldLock = heldLocks.get(lockName);
if (heldLock != null) {
@@ -96,7 +129,7 @@ public class TaskDistributedLockService {
do {
DistributedJobLockService.LockHandle delegate = distributedJobLockService.tryLock(lockName, ttl);
if (delegate != null) {
HeldLock newHeldLock = new HeldLock(lockName, delegate, ttl, heldLocks);
HeldLock newHeldLock = new HeldLock(lockName, module, delegate, ttl, heldLocks);
scheduleRenewal(lockName, newHeldLock, ttl);
heldLocks.put(lockName, newHeldLock);
activeLocks.register(lockName, newHeldLock.acquiredAtMillis, ttl.toMillis());
@@ -118,8 +151,12 @@ public class TaskDistributedLockService {
if (moduleType == null || moduleType.isBlank() || taskId == null || taskId <= 0) {
return null;
}
String normalizedModule = moduleType.trim().toLowerCase(Locale.ROOT).replace('_', '-');
return "task:" + normalizedModule + ":" + taskId;
return "task:" + normalizedModule(moduleType) + ":" + taskId;
}
/** 模块名归一化:锁名与封顶分档共用同一口径,两处不许各写一份。 */
private static String normalizedModule(String moduleType) {
return moduleType.trim().toLowerCase(Locale.ROOT).replace('_', '-');
}
/** 运维与同包用例的读数:当前在持的任务锁 → 已持有时长(毫秒)。空表=这台进程没有在持的锁。 */
@@ -142,7 +179,8 @@ public class TaskDistributedLockService {
long heldMillis = System.currentTimeMillis() - heldLock.acquiredAtMillis;
// 封顶按调用方**要的那条 TTL**算,不按下面钳过下限的那条:
// 下限是给续期节拍兜底的,拿它去放大封顶线会让短 TTL 的锁反而能压更久。
if (heldMillis > maxHoldMillis(ttl.toMillis())) {
long ceilingMillis = maxHoldMillis(heldLock.module, ttl.toMillis());
if (heldMillis > ceilingMillis) {
// 封顶:不再续期,让键在 TTL 内自己过期。故意不主动 del——持有方可能只是慢,
// 由它跑完时那次带 token 的 RELEASE 去收尾更安全(token 不匹配即 0,不会误删接管者的锁)。
heldLock.closed.set(true);
@@ -151,7 +189,7 @@ public class TaskDistributedLockService {
log.error("[task-lock] 持锁超过上限,停止续期 lockName={} heldMs={} ceilingMs={} ttlMs={} —— "
+ "持有方已卡死,本节点不应再对该资源做破坏性写操作;"
+ "本锁最迟 TTL 后可被其它实例接管",
lockName, heldMillis, maxHoldMillis(ttl.toMillis()), ttlMillis);
lockName, heldMillis, ceilingMillis, ttlMillis);
return;
}
if (renewWithRetry(lockName, heldLock)) {
@@ -175,14 +213,24 @@ public class TaskDistributedLockService {
}
}
/** 封顶随 TTL 缩放:调用方给了更长的 TTL,就该配更长的容忍线。 */
private long maxHoldMillis(long ttlMillis) {
return Math.max(maxHoldFloorMillis, MAX_HOLD_TTL_MULTIPLE * ttlMillis);
/** 封顶=max(本模块下限, 6×TTL):调用方给了更长的 TTL,就该配更长的容忍线。 */
private long maxHoldMillis(String module, long ttlMillis) {
return Math.max(maxHoldFloorsMillis.getOrDefault(module, defaultMaxHoldFloorMillis()),
MAX_HOLD_TTL_MULTIPLE * ttlMillis);
}
/** 测试接缝:把 30 分钟的下限压到毫秒级,才能在用例里真走到封顶那一条路。 */
void setMaxHoldFloorMillisForTest(long floorMillis) {
this.maxHoldFloorMillis = Math.max(1L, floorMillis);
/** 测试接缝:整表替换分档线(缺 {@value #DEFAULT_FLOOR_KEY} 时该档走 1 毫秒,用例本就该压到毫秒级)。 */
void setMaxHoldFloorsForTest(Map<String, Long> floorsMillis) {
this.maxHoldFloorsMillis = Map.copyOf(floorsMillis);
}
/** 出厂分档线(只读),供同包用例钉住:每一档都不许落回该模块合法持锁时长以内。 */
static Map<String, Long> shippedMaxHoldFloorsMillis() {
return MAX_HOLD_FLOOR_MILLIS;
}
private long defaultMaxHoldFloorMillis() {
return maxHoldFloorsMillis.getOrDefault(DEFAULT_FLOOR_KEY, 1L);
}
/**
@@ -239,6 +287,8 @@ public class TaskDistributedLockService {
private static final class HeldLock {
private final String lockName;
/** 归一化模块名:封顶按模块分档,释放/续期都拿它查线,不再回头解析锁名。 */
private final String module;
private final DistributedJobLockService.LockHandle delegate;
private final Duration ttl;
private final long acquiredAtMillis;
@@ -248,9 +298,10 @@ public class TaskDistributedLockService {
private final AtomicInteger depth = new AtomicInteger(1);
private final AtomicBoolean closed = new AtomicBoolean();
private HeldLock(String lockName, DistributedJobLockService.LockHandle delegate, Duration ttl,
Map<String, HeldLock> ownerLocks) {
private HeldLock(String lockName, String module, DistributedJobLockService.LockHandle delegate,
Duration ttl, Map<String, HeldLock> ownerLocks) {
this.lockName = lockName;
this.module = module;
this.delegate = delegate;
this.ttl = ttl;
this.acquiredAtMillis = System.currentTimeMillis();
@@ -4,6 +4,7 @@ import com.nanri.aiimage.common.service.DistributedJobLockService;
import org.junit.jupiter.api.Test;
import java.time.Duration;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -82,14 +83,87 @@ class TaskDistributedLockServiceLeakTest {
assertTrue(service.activeHeldMillis().isEmpty(), "最后一层在别的线程上放,也必须算放过");
}
@Test
void eachModuleCeilingSitsAboveItsOwnLegitLongestHold() {
// 校准样本=两台 7 天容器日志里 [task-lock-held](=真跑完并释放)的分布,10-22 取。
// 只认「放过」不认「在持」:在持那一路按定义包含还没放的锁,拿它定线等于把封顶定成无限。
// similar-asin 主机A 7845 次放过,最长 105.9 分(新代码上线后 2 小时窗口内 46 次,最长 49.8 分)
// appearance-patent 主机B 660 次放过,最长 453.8 分;对应任务墙钟 9.4 小时、状态 SUCCESS
// collect-data 两台 1079 次放过,最长 9.2 分
// 这条判据防的是以后有人拿「锁压 30 分钟太久了」当理由,把某一档调回该模块合法区间以内。
Map<String, Long> floors = TaskDistributedLockService.shippedMaxHoldFloorsMillis();
long similarAsinLegitMax = Duration.ofMinutes(105).toMillis() + 54_000L;
long patentLegitMax = Duration.ofMinutes(453).toMillis() + 48_000L;
long defaultFloor = floors.get(TaskDistributedLockService.DEFAULT_FLOOR_KEY);
assertTrue(defaultFloor >= 2 * 60 * 60_000L,
"默认档不得低于 2 小时:similar-asin 合法放过实测到 105.9 分,"
+ "把所有一档压回 30 分钟那种线,现网已实测会把慢但活着的大单当卡死治");
assertTrue(floors.get("similar-asin") >= similarAsinLegitMax * 3 / 2,
"similar-asin 必须落在自身合法最长(105.9 分)之上且留有余量");
assertTrue(floors.get("appearance-patent") >= patentLegitMax * 3 / 2,
"appearance-patent 的大单本来就要跑 7.6 小时,用一根平线去套会把它当僵尸掐");
// 反向也钉:分档不是「干脆不设」。封顶存在的唯一意义是终结 11.3 小时那种永久僵尸锁。
floors.forEach((module, millis) -> assertTrue(millis <= 12 * 60 * 60_000L,
module + " 的封顶线被抬成「几乎没有」了:" + millis));
}
@Test
void ceilingIsLookedUpPerModuleNotGlobally() throws Exception {
// 只钉静态表还不够:得证明续期真的按**这把锁所属模块**去查线。
// 两档一起放到毫秒级,越界的那把必须停、还在界内的那把必须继续——
// 若封顶退回读一根全局线,两个读数会一起停,这条用例就抓不住。
AtomicInteger similarAsinRenews = new AtomicInteger();
AtomicInteger patentRenews = new AtomicInteger();
TaskDistributedLockService service = twoModuleService(similarAsinRenews, patentRenews);
service.setMaxHoldFloorsForTest(Map.of(
TaskDistributedLockService.DEFAULT_FLOOR_KEY, 1L, // 没单独建档的模块走这条
"similar-asin", 1L, // ttl 300ms → 封顶 = 6×300 = 1.8s
"appearance-patent", 10 * 60 * 60_000L)); // 10 小时:本用例时长内绝不会越界
TaskDistributedLockService.LockHandle similarAsin =
service.acquire("similar-asin", TASK_ID, Duration.ofMillis(300), 0L);
TaskDistributedLockService.LockHandle patent =
service.acquire("APPEARANCE_PATENT", 31891L, Duration.ofMillis(300), 0L);
Thread.sleep(5_000L);
assertTrue(similarAsinRenews.get() >= 1, "similar-asin 没续过期=什么都没量到");
assertTrue(patentRenews.get() >= 1, "appearance-patent 没续过期=什么都没量到");
int similarAsinAtStop = similarAsinRenews.get();
int patentAtStop = patentRenews.get();
Thread.sleep(3_000L);
assertEquals(similarAsinAtStop, similarAsinRenews.get(),
"similar-asin 过 1.8 秒还在续期=分档线没生效");
assertTrue(patentRenews.get() > patentAtStop,
"appearance-patent 停下来了=封顶退成了全局一根线,把合法长档也一起掐了");
similarAsin.close();
patent.close();
}
/** 两个模块各自计数 renew,用于判「哪一把停了、哪一把还在续」。 */
private TaskDistributedLockService twoModuleService(AtomicInteger similarAsinRenews,
AtomicInteger patentRenews) {
DistributedJobLockService delegate = mock(DistributedJobLockService.class);
when(delegate.tryLock(anyString(), any(Duration.class))).thenAnswer(invocation -> {
boolean similarAsin = ((String) invocation.getArgument(0)).startsWith("task:similar-asin:");
AtomicInteger counter = similarAsin ? similarAsinRenews : patentRenews;
DistributedJobLockService.LockHandle inner = mock(DistributedJobLockService.LockHandle.class);
when(inner.renew(any(Duration.class))).thenAnswer(renew -> {
counter.incrementAndGet();
return true;
});
return inner;
});
return new TaskDistributedLockService(delegate);
}
@Test
void renewalStopsOnceHoldPassesTheCeiling() throws Exception {
AtomicInteger renewCalls = new AtomicInteger();
DistributedJobLockService.LockHandle[] inner = new DistributedJobLockService.LockHandle[1];
TaskDistributedLockService service = serviceWithRenewCounting(renewCalls, inner);
// ttl 300ms → 续期节拍钳到下限 1s,封顶 = max(200ms, 6×300ms) = 1.8s:
// ttl 300ms → 续期节拍钳到下限 1s,封顶 = max(1ms, 6×300ms) = 1.8s:
// 第一次续期(≈1s)还在界内,第二次(≈2s)越界即停。
service.setMaxHoldFloorMillisForTest(200L);
service.setMaxHoldFloorsForTest(Map.of("similar-asin", 1L));
TaskDistributedLockService.LockHandle handle =
service.acquire("similar-asin", TASK_ID, Duration.ofMillis(300), 0L);