diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskDistributedLockService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskDistributedLockService.java
index cdece47e1..e6f2568d8 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskDistributedLockService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/task/service/TaskDistributedLockService.java
@@ -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"。
+ *
+ *
下限按模块分档,是 10-22 拿两台 7 天容器日志的「放过」分布校准的
+ * (判据只用 {@code [task-lock-held]}=真跑完并释放的那些,不用在持读数——后者按定义
+ * 包含还没放的活)。合法持锁时长在两个模块上差 5 倍,一根平线必顾此失彼:
+ *
+ * - {@code similar-asin}:7845 次放过,最长 105.9 分钟(主机A);
+ * 新代码上线后 2 小时窗口内 46 次放过最长 49.8 分钟。取 4 小时=约 2.3 倍余量。
+ * - {@code appearance-patent}:660 次放过,最长 453.8 分钟(7.6 小时)(主机B),
+ * 且对应任务墙钟 9.4 小时、状态 SUCCESS——它的大单本来就要跑一整夜。取 12 小时。
+ * - 其余(collect-data 最长 9.2 分钟、brand/publish/price-track 都在 0.1 分钟量级):
+ * 走默认 2 小时。
+ *
+ *
+ * 为什么不是一根线:封顶第一版取 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 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 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 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 floorsMillis) {
+ this.maxHoldFloorsMillis = Map.copyOf(floorsMillis);
+ }
+
+ /** 出厂分档线(只读),供同包用例钉住:每一档都不许落回该模块合法持锁时长以内。 */
+ static Map 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 ownerLocks) {
+ private HeldLock(String lockName, String module, DistributedJobLockService.LockHandle delegate,
+ Duration ttl, Map ownerLocks) {
this.lockName = lockName;
+ this.module = module;
this.delegate = delegate;
this.ttl = ttl;
this.acquiredAtMillis = System.currentTimeMillis();
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskDistributedLockServiceLeakTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskDistributedLockServiceLeakTest.java
index e584f33ea..3c3a62b63 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskDistributedLockServiceLeakTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/task/service/TaskDistributedLockServiceLeakTest.java
@@ -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 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);