Compare commits

...

3 Commits

Author SHA1 Message Date
huangzd1997 b6f426ccbd docs(运维): §九 补齐 110 秒锁等待的持锁方取证与两处修法
上一版写"持锁方仍未定位"是错的,实际已定位到外观专利的 stale 恢复路径。
同时记两条当时看着像证据其实不是的判据(CglibAopProxy 出现在栈里 ≠ 在事务里;
burst 之后抓的线程转储不能当反证),以及 MySQL 业务账号无 PROCESS、加权限留人工决定。
2026-09-28 14:11:49 +08:00
huangzd1997 fecc19b52f fix(外观专利): stale 恢复不再把整批 LLM 包进事务,行锁不再持十几分钟
那 50 秒锁等待的持锁方就是这里:三个调用点把整个 finalizeStaleTask 包进
PROPAGATION_REQUIRES_NEW,而恢复分支里 submitLlmBatches 每批开头的 touchRunning
是 UPDATE biz_task_file_job ... WHERE id=? AND status='RUNNING',锁要活到串行发完
整批 LLM 请求(线上实测单批 costMs=1077959)之后才释放。改为只把封口和 finalizeTask
各自包成短事务,LLM 批次留在事务外;另在发批前查 isActualTransactionActive 做回归哨兵。
同源的 SimilarAsinTaskService 一直是正确形状,这里只是回到一致。
2026-09-28 14:11:36 +08:00
huangzd1997 a2f278c4c4 fix(任务): 卡死自愈扫描不再被一行的锁等待作废整轮
线上 12:58–13:13 每 110 秒一次 1205:扫描按 updated_at 升序取到的第一行正被另一台
持着行锁,一抛就把本轮已复位成功的 job 的 dispatch 事件一起带走(它们已是 PENDING
却没人派发),该判终态失败的作业也不 finalize。改成循环体逐行 try/catch、派发也逐个包,
只跳过这一行。刻意不加事务:每行本就带 status+updated_at 的幂等 CAS 条件。
2026-09-28 14:11:26 +08:00
4 changed files with 246 additions and 76 deletions
@@ -652,14 +652,7 @@ public class AppearancePatentTaskService {
continue;
}
try (lockHandle) {
if (transactionManager != null) {
inNewTransaction(() -> {
finalizeStaleTask(task.getId(), "Python interrupted before uploading final appearance patent result");
return null;
});
} else {
finalizeStaleTask(task.getId(), "Python interrupted before uploading final appearance patent result");
}
finalizeStaleTask(task.getId(), "Python interrupted before uploading final appearance patent result");
}
}
finalizeNoUploadStaleTasks();
@@ -669,19 +662,6 @@ public class AppearancePatentTaskService {
if (taskId == null || taskId <= 0) {
return;
}
if (transactionManager != null) {
TaskDistributedLockService.LockHandle lockHandle = acquireTaskLock(taskId, 0L);
if (lockHandle == null) {
return;
}
try (lockHandle) {
inNewTransaction(() -> {
finalizeStaleTask(taskId, "Python interrupted before uploading final appearance patent result");
return null;
});
}
return;
}
TaskDistributedLockService.LockHandle lockHandle = acquireTaskLock(taskId, 0L);
if (lockHandle == null) {
return;
@@ -777,14 +757,7 @@ public class AppearancePatentTaskService {
log.warn("[appearance-patent] 心跳正常但 {} 分钟无结果分片上报,按卡死收尾 taskId={} lastResultAt={}",
minutes, task.getId(), lastResultAt);
String error = "Python heartbeat alive but no result chunk uploaded for " + minutes + " minutes";
if (transactionManager != null) {
inNewTransaction(() -> {
finalizeStaleTask(task.getId(), error);
return null;
});
} else {
finalizeStaleTask(task.getId(), error);
}
finalizeStaleTask(task.getId(), error);
}
}
}
@@ -929,6 +902,15 @@ public class AppearancePatentTaskService {
task.getId(), job.getId(), candidates.size(), batchSize, flushRemainder);
return;
}
if (TransactionSynchronizationManager.isActualTransactionActive()) {
// 守住"整批 LLM 跑在事务里"这一类回归:下面循环每批开头的 touchRunning 是
// UPDATE biz_task_file_job ... WHERE id=? AND status='RUNNING',本方法一旦处在事务中,
// 这把行锁就要持到全部批次结束才释放(线上实测一批 18 分钟),另一台的卡死自愈扫描
// 于是每 110 秒撞一次 50 秒锁等待、并且整轮作废。历史上真发生过,见
// docs/ops/prod-decisions-2026-09-28.md §9。
log.error("[appearance-patent] llm 批次正跑在事务里,行锁会持到批次结束 taskId={} jobId={} pendingRows={}",
task.getId(), job.getId(), submitLimit);
}
int batchTotal = Math.max(1, (submitLimit + batchSize - 1) / batchSize);
int batchIndex = 1;
for (int i = 0; i < submitLimit; i += batchSize) {
@@ -1196,6 +1178,17 @@ public class AppearancePatentTaskService {
touchJavaSideTaskActivity(task.getId());
}
/**
* stale 判死收尾:事务只包住真正需要原子的两段(封口状态批量更新、任务终态 + 结果 + 组装作业入队),
* **LLM 批次留在事务之外**。
*
* <p>外层调用点曾把整个方法包进 {@code inNewTransaction},于是恢复分支里
* {@code submitLlmBatches} 每批开头 {@code touchRunning} 对 biz_task_file_job 取的 X 锁,
* 要一直活到串行发完整批 LLM 请求
* (线上实测单批 costMs=1077959)之后才释放——两台的卡死自愈扫描 UPDATE 同一行,
* 每 110 秒撞一次 50 秒锁等待,还顺手按住一条 Hikari 连接十几分钟、并把已扣过 LLM 次数的状态
* 置于可回滚的位置。同源的 {@code SimilarAsinTaskService#finalizeStaleTask} 一直是这个形状。
*/
private void finalizeStaleTask(Long taskId, String error) {
FileTaskEntity task = fileTaskMapper.selectById(taskId);
if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || !STATUS_RUNNING.equals(task.getStatus())) {
@@ -1204,7 +1197,14 @@ public class AppearancePatentTaskService {
if (tryRecoverTimedOutPythonTask(task)) {
return;
}
finalizeTask(task, error, allRowCount(task), true);
if (transactionManager == null) {
finalizeTask(task, error, allRowCount(task), true);
return;
}
inNewTransaction(() -> {
finalizeTask(task, error, allRowCount(task), true);
return null;
});
}
private boolean tryRecoverTimedOutPythonTask(FileTaskEntity task) {
@@ -1229,7 +1229,10 @@ public class AppearancePatentTaskService {
return false;
}
if (!uploadComplete) {
int forcedScopes = markSubmissionCompleteOnPythonTimeout(taskId);
// 封口是多行 scope 状态更新,单独占一个短事务;紧随其后的 LLM 批次不在事务里
int forcedScopes = transactionManager == null
? markSubmissionCompleteOnPythonTimeout(taskId)
: inNewTransaction(() -> markSubmissionCompleteOnPythonTimeout(taskId));
if (forcedScopes <= 0) {
log.warn("[appearance-patent] stale recovery aborted because submission could not be marked complete taskId={}",
taskId);
@@ -342,65 +342,83 @@ public class TaskFileJobService {
Map<Long, TaskFileJobEntity> originalJobsById = jobs.stream()
.collect(Collectors.toMap(TaskFileJobEntity::getId, job -> job, (a, b) -> a));
for (TaskFileJobEntity job : jobs) {
if ("FAILED".equals(job.getStatus())
&& job.getRetryCount() != null && job.getRetryCount() >= MAX_RETRY_COUNT) {
exhaustedJobIds.add(job.getId());
originalExhaustedById.put(job.getId(), job);
continue;
}
if ("PENDING".equals(job.getStatus())) {
// PENDING 僵尸兜底:补发 dispatch 事件(worker claim 幂等),
// 并累加 retryCount 防无限重发;注意不翻转状态,
// 避免与真实 PENDING 竞争 worker 的 claim 条件更新冲突。
try {
if ("FAILED".equals(job.getStatus())
&& job.getRetryCount() != null && job.getRetryCount() >= MAX_RETRY_COUNT) {
exhaustedJobIds.add(job.getId());
originalExhaustedById.put(job.getId(), job);
continue;
}
if ("PENDING".equals(job.getStatus())) {
// PENDING 僵尸兜底:补发 dispatch 事件(worker claim 幂等),
// 并累加 retryCount 防无限重发;注意不翻转状态,
// 避免与真实 PENDING 竞争 worker 的 claim 条件更新冲突。
int retryCount = job.getRetryCount() == null ? 0 : job.getRetryCount();
int nextRetryCount = Math.min(MAX_RETRY_COUNT - 1, retryCount + 1);
int updated = taskFileJobMapper.update(null, new LambdaUpdateWrapper<TaskFileJobEntity>()
.eq(TaskFileJobEntity::getId, job.getId())
.eq(TaskFileJobEntity::getStatus, "PENDING")
.eq(job.getUpdatedAt() != null, TaskFileJobEntity::getUpdatedAt, job.getUpdatedAt())
.isNull(job.getUpdatedAt() == null, TaskFileJobEntity::getUpdatedAt)
.set(TaskFileJobEntity::getRetryCount, nextRetryCount)
.set(TaskFileJobEntity::getUpdatedAt, LocalDateTime.now()));
if (updated > 0) {
eventJobIds.add(job.getId());
}
continue;
}
int retryCount = job.getRetryCount() == null ? 0 : job.getRetryCount();
int nextRetryCount = Math.min(MAX_RETRY_COUNT - 1, retryCount + 1);
int updated = taskFileJobMapper.update(null, new LambdaUpdateWrapper<TaskFileJobEntity>()
int nextRetryCount = Math.min(MAX_RETRY_COUNT, retryCount + 1);
LocalDateTime now = LocalDateTime.now();
LambdaUpdateWrapper<TaskFileJobEntity> update = new LambdaUpdateWrapper<TaskFileJobEntity>()
.eq(TaskFileJobEntity::getId, job.getId())
.eq(TaskFileJobEntity::getStatus, "PENDING")
.eq(TaskFileJobEntity::getStatus, "RUNNING")
.eq(job.getUpdatedAt() != null, TaskFileJobEntity::getUpdatedAt, job.getUpdatedAt())
.isNull(job.getUpdatedAt() == null, TaskFileJobEntity::getUpdatedAt)
.set(TaskFileJobEntity::getRetryCount, nextRetryCount)
.set(TaskFileJobEntity::getUpdatedAt, LocalDateTime.now()));
if (updated > 0) {
eventJobIds.add(job.getId());
.set(TaskFileJobEntity::getUpdatedAt, now);
if (nextRetryCount >= MAX_RETRY_COUNT) {
int updated = taskFileJobMapper.update(null, update
.set(TaskFileJobEntity::getStatus, "FAILED")
.set(TaskFileJobEntity::getErrorMessage, "文件生成任务运行超时,已达到最大重试次数")
.set(TaskFileJobEntity::getFinishedAt, now)
.set(TaskFileJobEntity::getTerminalCallbackAt, null));
if (updated > 0) {
exhaustedJobIds.add(job.getId());
}
continue;
}
continue;
}
int retryCount = job.getRetryCount() == null ? 0 : job.getRetryCount();
int nextRetryCount = Math.min(MAX_RETRY_COUNT, retryCount + 1);
LocalDateTime now = LocalDateTime.now();
LambdaUpdateWrapper<TaskFileJobEntity> update = new LambdaUpdateWrapper<TaskFileJobEntity>()
.eq(TaskFileJobEntity::getId, job.getId())
.eq(TaskFileJobEntity::getStatus, "RUNNING")
.eq(job.getUpdatedAt() != null, TaskFileJobEntity::getUpdatedAt, job.getUpdatedAt())
.isNull(job.getUpdatedAt() == null, TaskFileJobEntity::getUpdatedAt)
.set(TaskFileJobEntity::getRetryCount, nextRetryCount)
.set(TaskFileJobEntity::getUpdatedAt, now);
if (nextRetryCount >= MAX_RETRY_COUNT) {
int updated = taskFileJobMapper.update(null, update
.set(TaskFileJobEntity::getStatus, "FAILED")
.set(TaskFileJobEntity::getErrorMessage, "文件生成任务运行超时,已达到最大重试次数")
.set(TaskFileJobEntity::getFinishedAt, now)
.set(TaskFileJobEntity::getStatus, "PENDING")
.set(TaskFileJobEntity::getErrorMessage, "文件生成任务运行超时,已重新排队")
.set(TaskFileJobEntity::getFinishedAt, null)
.set(TaskFileJobEntity::getTerminalCallbackAt, null));
if (updated > 0) {
exhaustedJobIds.add(job.getId());
reset++;
eventJobIds.add(job.getId());
}
continue;
}
int updated = taskFileJobMapper.update(null, update
.set(TaskFileJobEntity::getStatus, "PENDING")
.set(TaskFileJobEntity::getErrorMessage, "文件生成任务运行超时,已重新排队")
.set(TaskFileJobEntity::getFinishedAt, null)
.set(TaskFileJobEntity::getTerminalCallbackAt, null));
if (updated > 0) {
reset++;
eventJobIds.add(job.getId());
} catch (RuntimeException ex) {
// 这一行为什么必须单独吞:它正被别的事务占着时会等满 innodb_lock_wait_timeout
// 再抛 1205。整轮向外抛的代价不是这一行没修好,而是同批其余 199 行这轮全不看、
// 本轮已复位成功的 job 也发不出 dispatch(它们在 400 行之后才发布),
// 于是被锁的行每轮都排在最前(ORDER BY updated_at ASC)——线上实测每 110 秒
// 重复一次「等 50 秒 + 整轮作废」,卡住的任务在这段时间里根本没人管。
// jobId 必须打出来:它是下一轮定位持锁方的唯一线索。
log.warn("[task-file-job] stuck reset 单行失败已跳过,继续处理其余行 jobId={} scanned={} taskId={} moduleType={} status={} retryCount={} err={}",
job.getId(), jobs.size(), job.getTaskId(), job.getModuleType(), job.getStatus(),
job.getRetryCount(), ex.getMessage());
}
}
if (!eventJobIds.isEmpty()) {
Map<Long, TaskFileJobEntity> refreshedById = refreshJobsByIds(eventJobIds);
for (Long jobId : eventJobIds) {
publishDispatchEvent(refreshedById.get(jobId));
try {
publishDispatchEvent(refreshedById.get(jobId));
} catch (RuntimeException ex) {
// 派发监听器是同步执行的,一个 job 派发失败不能带走同批其余 job
log.warn("[task-file-job] stuck reset 派发事件发布失败,不影响其余 job jobId={} err={}",
jobId, ex.getMessage());
}
}
}
if (!exhaustedJobIds.isEmpty()) {
@@ -14,6 +14,7 @@ import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.dao.CannotAcquireLockException;
import java.time.LocalDateTime;
import java.util.List;
@@ -23,7 +24,9 @@ import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -201,6 +204,45 @@ class TaskFileJobServiceTest {
assertTrue(service.isRetryExhausted(110L));
}
@Test
void lockedJobRowDoesNotAbortTheRestOfStuckScan() {
TaskFileJobEntity locked = runningJob(201L, 1, LocalDateTime.now().minusHours(1));
TaskFileJobEntity healthy = runningJob(202L, 1, LocalDateTime.now().minusHours(1));
TaskFileJobEntity refreshed = runningJob(202L, 2, LocalDateTime.now());
refreshed.setStatus("PENDING");
when(taskFileJobMapper.selectList(any())).thenReturn(List.of(locked, healthy));
when(taskFileJobMapper.update(isNull(), any(LambdaUpdateWrapper.class)))
.thenThrow(new CannotAcquireLockException("Lock wait timeout exceeded"))
.thenReturn(1);
when(taskFileJobMapper.selectBatchIds(any())).thenReturn(List.of(refreshed));
TaskFileJobService service = new TaskFileJobService(taskFileJobMapper, applicationEventPublisher);
TaskFileJobService.StuckJobResetResult result = service.resetStuckRunningJobsDetailed(30, 20);
assertEquals(1, result.resetCount());
ArgumentCaptor<TaskFileJobDispatchEvent> events = ArgumentCaptor.forClass(TaskFileJobDispatchEvent.class);
verify(applicationEventPublisher).publishEvent(events.capture());
assertEquals(202L, events.getValue().jobId());
}
@Test
void alreadyResetJobsStillDispatchWhenOnePublishFails() {
TaskFileJobEntity first = runningJob(203L, 1, LocalDateTime.now().minusHours(1));
TaskFileJobEntity second = runningJob(204L, 1, LocalDateTime.now().minusHours(1));
when(taskFileJobMapper.selectList(any())).thenReturn(List.of(first, second));
when(taskFileJobMapper.update(isNull(), any(LambdaUpdateWrapper.class))).thenReturn(1);
when(taskFileJobMapper.selectBatchIds(any())).thenReturn(List.of(first, second));
doThrow(new IllegalStateException("listener boom"))
.doNothing()
.when(applicationEventPublisher).publishEvent(any(Object.class));
TaskFileJobService service = new TaskFileJobService(taskFileJobMapper, applicationEventPublisher);
TaskFileJobService.StuckJobResetResult result = service.resetStuckRunningJobsDetailed(30, 20);
assertEquals(2, result.resetCount());
verify(applicationEventPublisher, times(2)).publishEvent(any(Object.class));
}
private void assertUpdateContains(int nextRetry, LocalDateTime updatedAt) {
ArgumentCaptor<LambdaUpdateWrapper<TaskFileJobEntity>> update = updateCaptor();
verify(taskFileJobMapper).update(isNull(), update.capture());
+108 -1
View File
@@ -696,7 +696,114 @@ health 200、Flyway 137 无新迁移、`ERROR` 0 条、`AIIMAGE_ROCKETMQ_NAME_SE
`192.168.0.171` → `0.066/0.065/0.061 ms`。差 4 倍但**绝对值都可忽略**;
§四 说的 5–8 Mbps 只在**大块传输**(下载图片/上传对象)时咬人,别拿它去解释小 POST 的失败。
- **另一个纯运维项**(我没擅动,属可执行清单):`/root/BrandTesting/nohup.out` 已 **941,635,295 B**,
实测 30 秒长 27,021 B ≈ **1.1 GB/天**,比 §七 里任何容器日志都快;磁盘 492G 用了 156G(34%)暂时不致命。
实测 30 秒长 27,021 B(900 B/s)≈ **78 MB/天** —— 本条第一版把它写成了 "1.1 GB/天",是**乘法算错了 14 倍**
(1.1 GB/天 需要 13 kB/s);13:1x 另取一次 5 秒 4,700 B(940 B/s)与之吻合,两笔独立测量都对得上,
只有原来那个结论错。按 78 MB/天,900MB 约是 **12 天**积累。磁盘 492G 用了 156G(34%),完全不致命。
进程是 `nohup` 追加写、不能发信号重启 → 只能 `logrotate` 配 `copytruncate`(保留几轮 + 压缩)。
这是客户排障唯一的日志来源,保留策略要人点头,所以先记命令不执行。
## 九、卡住自愈扫描会被一行的锁等待作废整轮(症状与根因两处都已修,取证在案)
§六 那轮复测顺手查出来的第二个缺陷,性质不同:**它不是网络,是我们自己的定时任务**。
修了两处:§9.3 让扫描不再被一行拖垮(症状),§9.5 把整批 LLM 移出事务(根因,持锁方本身)。
只修 §9.3 的话 burst 不再作废整轮,但那 50 秒锁等仍会每 110 秒白占一条 Hikari 连接。
### 9.1 现场是什么样子
- 主机B `docker logs --since 40m`(窗口总行数 6,008 行自证)里 `CannotAcquireLockException` **9 次**,
失败时刻 `12:58:16 / 13:00:06 / 13:01:57 / 13:03:47 / 13:05:37 / 13:07:27 / 13:09:17 / 13:11:07 / 13:12:57`
—— **严格每 110 秒一次**,13:12:57 之后自行停止。110 = 60s `fixedDelay` + 50s `innodb_lock_wait_timeout`,
这个周期本身就是"同一行、同一处、每轮都撞"的指纹。
- 抛点的完整 SQL 与栈(同一段日志里抠出来的,不是推测):
`UPDATE biz_task_file_job SET retry_count=?,updated_at=?,status=?,error_message=?,finished_at=?,terminal_callback_at=? WHERE (id = ? AND status = ? AND updated_at …)`
→ `TaskFileJobMapper.update-Inline` → `TaskFileJobService.resetStuckRunningJobsDetailed(TaskFileJobService.java:390)`
→ `TaskResultFileJobWorker.resetStuckJobs(TaskResultFileJobWorker.java:101)`。
- 同期 job `20834`(`APPEARANCE_PATENT` / `ASSEMBLE_RESULT` / owner `server-110`)的一个 LLM 批次
`costMs=1077959`(18 分钟),窗口正好盖住上面这 15 分钟。
- MySQL 侧累计自证:`Innodb_row_lock_waits=354,493`、`Innodb_row_lock_time_max=51,199 ms`、
`Innodb_row_lock_time_avg=13 ms` → **平均 13 毫秒,尾巴 51 秒**:绝大多数锁等是正常排队,
出事的是极少数"被一个长事务按住"的行。慢日志里同类 50 秒锁等已 586 条,
8-31 / 9-08 / 9-16 各有一轮同样的 burst(历史热点 id 18399 命中 516 次)→ **不是今晚才有的**。
### 9.2 为什么"整轮作废"比"这一行没修好"严重得多
原实现第 344–399 行的循环**没有逐行容错**,而第 400–405 行的
`refreshJobsByIds` + `publishDispatchEvent` 排在循环**之后**。所以第 390 行一抛:
1. 本轮 SELECT 出来的其余最多 199 行不再看一眼(含真卡住该救的行);
2. **本轮已经复位成功的那些 job 一个 dispatch 事件都发不出去** —— 它们已经是 PENDING 了却没人派发,
要等下一轮扫描的 PENDING 分支再兜一次,每兜一次 `retry_count` +1,而 `MAX_RETRY_COUNT` 只有 5;
3. `exhaustedJobs` 直接丢空 → 该判终态失败的作业不 finalize,用户界面停在"处理中";
4. 这一轮的 50 秒白占一条 Hikari 连接 → 同一时间窗内 `Connection leak` 告警 7 条(阈值就是 50s)。
被锁的那一行按 `ORDER BY updated_at ASC` 每轮都排在最前面,于是 12:58–13:13 **每一轮都先撞它、
每一轮都整轮作废**,那 15 分钟里实际上没有任何自愈在跑。
### 9.3 修法(只收口这一处,不动事务边界)
`resetStuckRunningJobsDetailed` 循环体整体包 `try/catch (RuntimeException)`:单行失败只打一条
**带 jobId 的** WARN 并 `continue`;`publishDispatchEvent` 也改成逐个 job 独立包(监听器是同步执行的,
一个 job 派发失败不能带走同批其余)。刻意**不加**事务、不改 `@Transactional`、不动 CAS 条件 ——
每行本就带 `status + updated_at` 的幂等条件,跳过就是下一轮再收,重复执行不会双份复位。
新增两个回归测试:`lockedJobRowDoesNotAbortTheRestOfStuckScan`(第一行抛 1205,第二行仍被复位并派发)、
`alreadyResetJobsStillDispatchWhenOnePublishFails`(第一个事件发布抛异常,第二个仍发出)。
### 9.4 持锁方:外观专利的 stale 恢复把整批 LLM 包进了事务(已定位、已修)
这一节上一版写的是"仍未定位"。定位过程记在这里,因为其中两条判据是**错的**,值得留着的不是结论而是排除路径。
四条证据:
1. **同一笔 job 的三个数对上**:burst 期间主机B 报 1205 的那一行,就是主机A 上 job `20834`
(`APPEARANCE_PATENT` / `ASSEMBLE_RESULT` / owner `server-110`),它的 LLM 批次 `costMs=1077959`
= 18 分钟,把 12:58–13:13 整段盖住。两台 `AIIMAGE_INSTANCE_ID` 不同(`server-110` / `server-121`)
→ 这是**跨实例**持锁;`resetStuckRunningJobsDetailed` 的扫描条件不带 owner,所以 B 必然会去碰 A 正持有的行。
2. **锁由哪条语句取**:`submitLlmBatches` 循环每批开头调 `TaskFileJobService.touchRunning`(:555,
`UPDATE biz_task_file_job SET updated_at=? WHERE id=? AND status='RUNNING'`),紧跟着才是
`llmClient.inspectRows` 的 HTTP(:926)。持锁方与被锁方打的是**同一行、同一把 X 锁**。
—— 注意取锁点**不是** `enqueueAssembleResult`:它对已 `RUNNING` 的行直接 return、不写(:63)。
3. **为什么这把锁能活 18 分钟**:`finalizeStaleTask` 的三个调用点原先都把**整个方法**包进
`PROPAGATION_REQUIRES_NEW`,而方法里 `tryRecoverTimedOutPythonTask` → `submitLlmForSubmittedChunk`(:1246)
→ `submitLlmBatches` 就是那 18 分钟。MyBatis-Spring 的语义:有环境事务时 mapper 调用不各自提交,
行锁持到最外层 commit;无环境事务时每次调用即刻提交、锁即时释放。
4. **被排除的干扰项**(都查过,别再重跑):全仓 `FOR UPDATE` 只有 shop-data-crawl 日锁与
`TaskScopePayloadStorageService:486` 两处,与本路径无关;今天全天 shop-data-crawl 删除调用 0 命中
(`拒绝删除` / `reconcile task after result deletion` / `deleteHistory` 各 0);worker、`touchRunning`、
MQ 消费链静态读下来都不带环境事务。
两条**当时看着像证据、其实不是**的:
- **`CglibAopProxy` 出现在栈里 ≠ 在事务里**。任何被代理的 bean 都会出现这一帧。判事务只能看
`TransactionInterceptor.invoke` / `DataSourceTransactionManager.doBegin` / `TransactionTemplate.execute`。
我按错的判据一度指认"brand-check 线程持事务",读源码后自己否掉(`CollectDataService.submitResult` 无
`@Transactional`,品牌检测本就注释说明刻意放在锁外)。
- **线程转储抓晚了不能当反证**。7 份转储(`jcmd <javapid> Thread.print`;A 机 java 是 **pid 12**,
pid 1 是 `bash /run.sh`,对它抓只会得 `AttachNotSupportedException`)里没有任何 `TransactionInterceptor.invoke`,
但抓样时刻 13:31 已在 burst(止于 13:12:57)之后 —— 只能证明"此刻没有"。
顺带:`kill -3 1` 发给 bash 是无效的(非交互 bash 忽略 SIGQUIT),既没伤害也没产生转储。
**对照**:同源模块 `SimilarAsinTaskService` 早就是正确形状(:991 只把 `finalizeTask` 包进短事务,
LLM 提交在事务外)。**AP 是唯一破坏这个约定的模块**,不是"全仓都这么写",所以本轮不需要横扫其它模块。
### 9.5 第二处修法:事务边界收到 `finalizeTask` 那一层
- 三个调用点(`finalizeStaleTasks` / `debugFinalizeStaleTask` / `finalizeNoUploadStaleTask`)去掉外层
`inNewTransaction`,改由 `finalizeStaleTask` 自己只在 `finalizeTask` 外面开短事务;
`tryRecoverTimedOutPythonTask` 里"封口"那段(多行 scope 状态更新)单独占一个短事务,紧随其后的 LLM 批次在事务外。
- 加**回归哨兵**:`submitLlmBatches` 发批前查 `TransactionSynchronizationManager.isActualTransactionActive()`,
命中即 ERROR 带 taskId/jobId/pendingRows —— 以后谁再把批次搬回事务里,日志会直接点名,不用重演今晚的抓转储。
- `finalizeTask` 内 `shouldAssembleSynchronously()` 恒为 false(出表走 MQ 异步),所以留在短事务里的只有
两次 select + 两次 update + enqueue + redis delete。
- 本轮**没动**的三件,各自理由:brand-check 的重试/预算参数(§八 已定性为坏上游,调参等于在坏上游上调)、
`selectRowsUpdatedAtByTaskIds`(SQL 已够窄,无慢日志证据)、给 MySQL 加 PROCESS 权限(见下)。
数据库侧想直接看 `information_schema.INNODB_TRX` / `performance_schema.data_lock_waits` 仍然不行:
业务账号 `CURRENT_USER()=root@172.19.0.1`(名字是 root,权限被削平)只有 `GRANT USAGE ON *.*` +
`aiimage.*` 表级授权,**没有 PROCESS**(读 `INNODB_TRX` 回 1227、读 `data_lock_waits` 回 1142),
`GRANT OPTION` 也只覆盖 `aiimage.*`,提不出全局权限;宿主机上没有可用 root 凭据
(`grep -rl MYSQL_ROOT_PASSWORD /opt/1panel` 无结果、无 `/root/.my.cnf`,容器 env 里那个口令实测 1045 不认)。
**给生产库加 PROCESS 属权限变更,不在本轮授权范围内,留给人工决定。** 于是改成让代码留钩子:
WARN 里带被锁的 `jobId`,而该 job 的执行日志(哪个实例、哪个批次、起止时刻)就在同一份日志里,
两边一对就能指认持锁方。**下次 burst 不用再抓转储。**