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 倍,一根平线必顾此失彼: + *

+ * + *

为什么不是一根线:封顶第一版取 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);