提交更新

2026-05-02 09:28:26 +08:00
parent aece8123c3
commit 3ce66a59ee
13 changed files with 380 additions and 33 deletions
@@ -127,6 +127,11 @@ public class PatrolDeleteTaskCacheService {
    }

    public void deleteTaskCache(Long taskId) {
+        evictTaskCacheOnly(taskId);
+        taskScopePayloadStorageService.deleteTaskScopePayloads(taskId, MODULE_TYPE);
+    }
+
+    public void evictTaskCacheOnly(Long taskId) {
        if (taskId == null || taskId <= 0) {
            return;
        }
@@ -137,7 +142,6 @@ public class PatrolDeleteTaskCacheService {
        } catch (Exception ex) {
            log.warn("[patrol-delete-cache] delete cache degraded taskId={} msg={}", taskId, ex.getMessage());
        }
-        taskScopePayloadStorageService.deleteTaskScopePayloads(taskId, MODULE_TYPE);
    }

    public void saveTaskCache(FileTaskEntity task) {
@@ -28,6 +28,7 @@ import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
 import com.nanri.aiimage.modules.task.service.TaskFileJobService;
 import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
 import com.nanri.aiimage.modules.task.service.TaskResultItemService;
+import com.nanri.aiimage.modules.task.service.TaskScopePayloadStorageService;
 import com.nanri.aiimage.modules.ziniao.service.ZiniaoShopSwitchService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -66,6 +67,7 @@ public class PatrolDeleteTaskService {
    private final TaskFileJobService taskFileJobService;
    private final TaskResultItemService taskResultItemService;
    private final TaskProgressSnapshotService taskProgressSnapshotService;
+    private final TaskScopePayloadStorageService taskScopePayloadStorageService;

    private FileTaskEntity loadTaskForExecution(Long taskId) {
        Map<Long, FileTaskEntity> cachedTasks = taskCacheService.getTaskCacheBatch(List.of(taskId));
@@ -135,32 +137,58 @@ public class PatrolDeleteTaskService {
    }

    public PatrolDeleteHistoryVo listHistory(Long userId) {
+        long startedAt = System.nanoTime();
        validateUserId(userId);
        PatrolDeleteHistoryVo vo = new PatrolDeleteHistoryVo();
        List<FileResultEntity> entities = fileResultMapper.selectList(new LambdaQueryWrapper<FileResultEntity>()
+                .select(FileResultEntity::getId,
+                        FileResultEntity::getTaskId,
+                        FileResultEntity::getModuleType,
+                        FileResultEntity::getSourceFilename,
+                        FileResultEntity::getSourceFileUrl,
+                        FileResultEntity::getResultFilename,
+                        FileResultEntity::getResultFileUrl,
+                        FileResultEntity::getSuccess,
+                        FileResultEntity::getErrorMessage,
+                        FileResultEntity::getUserId,
+                        FileResultEntity::getCreatedAt)
                .eq(FileResultEntity::getModuleType, MODULE_TYPE)
                .eq(FileResultEntity::getUserId, userId)
                .orderByDesc(FileResultEntity::getCreatedAt)
                .last("limit 100"));
+        long resultRowsLoadedAt = System.nanoTime();
        if (entities.isEmpty()) {
            vo.setItems(List.of());
+            log.info("[patrol-delete] history timing userId={} rows=0 totalMs={} resultQueryMs={} taskQueryMs=0 jobQueryMs=0 buildMs=0",
+                    userId, elapsedMs(startedAt, resultRowsLoadedAt), elapsedMs(startedAt, resultRowsLoadedAt));
            return vo;
        }

-        Map<Long, FileTaskEntity> taskMap = loadTaskMap(entities);
-        Map<Long, Map<Long, PatrolDeleteResultItemVo>> snapshotMap = buildSnapshotMap(taskMap);
+        Map<Long, FileTaskEntity> taskMap = loadHistoryTaskMap(entities);
+        long tasksLoadedAt = System.nanoTime();
        Map<Long, TaskFileJobEntity> jobMap = taskFileJobService.findAssembleJobsByResultIds(MODULE_TYPE, entities.stream()
                .map(FileResultEntity::getId)
                .filter(id -> id != null && id > 0)
                .distinct()
                .toList());
+        long jobsLoadedAt = System.nanoTime();
        List<PatrolDeleteResultItemVo> items = new ArrayList<>();
        for (FileResultEntity entity : entities) {
            FileTaskEntity task = taskMap.get(entity.getTaskId());
-            PatrolDeleteResultItemVo snapshot = snapshotMap.getOrDefault(entity.getTaskId(), Map.of()).get(entity.getId());
-            items.add(toHistoryItem(entity, task, snapshot, jobMap.get(entity.getId())));
+            items.add(toHistoryItem(entity, task, null, jobMap.get(entity.getId())));
        }
        vo.setItems(items);
+        long finishedAt = System.nanoTime();
+        log.info("[patrol-delete] history timing userId={} rows={} tasks={} jobs={} totalMs={} resultQueryMs={} taskQueryMs={} jobQueryMs={} buildMs={}",
+                userId,
+                entities.size(),
+                taskMap.size(),
+                jobMap.size(),
+                elapsedMs(startedAt, finishedAt),
+                elapsedMs(startedAt, resultRowsLoadedAt),
+                elapsedMs(resultRowsLoadedAt, tasksLoadedAt),
+                elapsedMs(tasksLoadedAt, jobsLoadedAt),
+                elapsedMs(jobsLoadedAt, finishedAt));
        return vo;
    }

@@ -417,17 +445,32 @@ public class PatrolDeleteTaskService {

    @Transactional
    public void deleteTask(Long taskId, Long userId) {
+        long startedAt = System.nanoTime();
        validateUserId(userId);
        FileTaskEntity task = loadTaskForExecution(taskId);
        if (task == null || !MODULE_TYPE.equals(task.getModuleType()) || !userId.equals(task.getUserId())) {
            throw new BusinessException("任务不存在");
        }
+        long taskLoadedAt = System.nanoTime();
        fileResultMapper.delete(new LambdaQueryWrapper<FileResultEntity>()
                .eq(FileResultEntity::getTaskId, taskId)
                .eq(FileResultEntity::getModuleType, MODULE_TYPE));
-        cleanupTaskAuxiliaryData(taskId);
+        long resultsDeletedAt = System.nanoTime();
+        cleanupTaskAuxiliaryDataFast(taskId);
+        long auxiliaryDeletedAt = System.nanoTime();
        fileTaskMapper.deleteById(taskId);
-        taskCacheService.deleteTaskCache(taskId);
+        long taskDeletedAt = System.nanoTime();
+        taskCacheService.evictTaskCacheOnly(taskId);
+        long finishedAt = System.nanoTime();
+        log.info("[patrol-delete] delete task timing taskId={} userId={} totalMs={} loadMs={} resultDeleteMs={} auxiliaryDeleteMs={} taskDeleteMs={} cacheMs={}",
+                taskId,
+                userId,
+                elapsedMs(startedAt, finishedAt),
+                elapsedMs(startedAt, taskLoadedAt),
+                elapsedMs(taskLoadedAt, resultsDeletedAt),
+                elapsedMs(resultsDeletedAt, auxiliaryDeletedAt),
+                elapsedMs(auxiliaryDeletedAt, taskDeletedAt),
+                elapsedMs(taskDeletedAt, finishedAt));
    }

    @Transactional
@@ -439,7 +482,7 @@ public class PatrolDeleteTaskService {
        }
        Long taskId = entity.getTaskId();
        fileResultMapper.deleteById(resultId);
-        cleanupResultAuxiliaryData(taskId, resultId);
+        cleanupResultAuxiliaryDataFast(taskId, resultId);
        reconcileTaskAfterResultRemoval(taskId);
    }

@@ -453,13 +496,12 @@ public class PatrolDeleteTaskService {
        }
        List<FileResultEntity> rows = listTaskRows(taskId);
        if (rows.isEmpty()) {
-            cleanupTaskAuxiliaryData(taskId);
+            cleanupTaskAuxiliaryDataFast(taskId);
            fileTaskMapper.deleteById(taskId);
-            taskCacheService.deleteTaskCache(taskId);
+            taskCacheService.evictTaskCacheOnly(taskId);
            return;
        }
        updateTaskStatusFromRows(task, rows);
-        persistSnapshotJson(task, buildSnapshotFromDb(task, rows));
        fileTaskMapper.updateById(task);
        taskCacheService.saveTaskCache(task);
    }
@@ -470,11 +512,23 @@ public class PatrolDeleteTaskService {
        taskFileJobService.deleteTaskJobs(taskId, MODULE_TYPE);
    }

+    private void cleanupTaskAuxiliaryDataFast(Long taskId) {
+        taskResultItemService.deleteTaskItemsRowsOnly(taskId, MODULE_TYPE);
+        taskScopePayloadStorageService.deleteTaskScopePayloadRowsOnly(taskId, MODULE_TYPE);
+        taskProgressSnapshotService.delete(taskId, MODULE_TYPE);
+        taskFileJobService.deleteTaskJobs(taskId, MODULE_TYPE);
+    }
+
    private void cleanupResultAuxiliaryData(Long taskId, Long resultId) {
        taskResultItemService.deleteResultItem(taskId, MODULE_TYPE, resultId);
        taskFileJobService.deleteResultJobs(taskId, MODULE_TYPE, resultId);
    }

+    private void cleanupResultAuxiliaryDataFast(Long taskId, Long resultId) {
+        taskResultItemService.deleteResultItemRowsOnly(taskId, MODULE_TYPE, resultId);
+        taskFileJobService.deleteResultJobs(taskId, MODULE_TYPE, resultId);
+    }
+
    private long countTasks(Long userId, List<String> statuses) {
        Long count = fileTaskMapper.selectCount(new LambdaQueryWrapper<FileTaskEntity>()
                .eq(FileTaskEntity::getModuleType, MODULE_TYPE)
@@ -524,6 +578,35 @@ public class PatrolDeleteTaskService {
        return taskMap;
    }

+    private Map<Long, FileTaskEntity> loadHistoryTaskMap(List<FileResultEntity> entities) {
+        List<Long> taskIds = entities.stream()
+                .map(FileResultEntity::getTaskId)
+                .filter(id -> id != null && id > 0)
+                .distinct()
+                .toList();
+        Map<Long, FileTaskEntity> taskMap = new LinkedHashMap<>();
+        if (taskIds.isEmpty()) {
+            return taskMap;
+        }
+        int batchSize = Math.max(1, taskPressureProperties.getDbSelectBatchSize());
+        for (int start = 0; start < taskIds.size(); start += batchSize) {
+            int end = Math.min(start + batchSize, taskIds.size());
+            List<FileTaskEntity> tasks = fileTaskMapper.selectList(new LambdaQueryWrapper<FileTaskEntity>()
+                    .select(FileTaskEntity::getId,
+                            FileTaskEntity::getModuleType,
+                            FileTaskEntity::getStatus,
+                            FileTaskEntity::getFinishedAt)
+                    .eq(FileTaskEntity::getModuleType, MODULE_TYPE)
+                    .in(FileTaskEntity::getId, taskIds.subList(start, end)));
+            for (FileTaskEntity task : tasks) {
+                if (task != null && task.getId() != null) {
+                    taskMap.put(task.getId(), task);
+                }
+            }
+        }
+        return taskMap;
+    }
+
    private Map<Long, Map<Long, PatrolDeleteResultItemVo>> buildSnapshotMap(Map<Long, FileTaskEntity> taskMap) {
        Map<Long, Map<Long, PatrolDeleteResultItemVo>> out = new LinkedHashMap<>();
        for (Map.Entry<Long, FileTaskEntity> entry : taskMap.entrySet()) {
@@ -925,6 +1008,10 @@ public class PatrolDeleteTaskService {
        return Integer.valueOf(RESULT_SUCCESS).equals(dbValue);
    }

+    private long elapsedMs(long start, long end) {
+        return (end - start) / 1_000_000L;
+    }
+
    private List<PatrolDeleteResultItemVo> parseTaskSnapshots(String json) {
        if (blank(json)) {
            return new ArrayList<>();