Spring Boot中长时间运行API请求的优雅取消与管理

import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

@Service
public class LongRunningTaskService {

    // 使用固定大小的线程池来执行长时间运行的任务
    private final ExecutorService executorService = Executors.newFixedThreadPool(5);

    // 存储任务ID和对应的Future对象，用于跟踪和取消
    private final Map<String, Future<?>> runningTasks = new ConcurrentHashMap<>();

    /**
     * 提交一个长时间运行的任务
     * @param timeToRun 模拟任务运行的秒数
     * @return 任务的唯一ID
     */
    public String submitTask(int timeToRun) {
        String taskId = UUID.randomUUID().toString();
        System.out.println("提交任务，ID: " + taskId + ", 预计运行 " + timeToRun + " 秒");

        Future<?> future = executorService.submit(() -> {
            try {
                for (int i = 0; i < timeToRun; i++) {
                    // 模拟耗时操作
                    Thread.sleep(1000);
                    System.out.println("任务 " + taskId + " 正在运行，第 " + (i + 1) + " 秒...");

                    // 检查线程是否被中断，实现协作式取消
                    if (Thread.currentThread().isInterrupted()) {
                        System.out.println("任务 " + taskId + " 收到中断信号，正在退出。");
                        // 抛出InterruptedException以便外部捕获或中断链上传递
                        throw new InterruptedException("Task was interrupted by cancellation request.");
                    }
                }
                System.out.println("任务 " + taskId + " 已完成。");
            } catch (InterruptedException e) {
                System.out.println("任务 " + taskId + " 在执行过程中被中断。");
                // 捕获InterruptedException后，通常需要重新设置中断状态
                // 因为捕获InterruptedException会清除中断标志
                Thread.currentThread().interrupt();
            } catch (Exception e) {
                System.err.println("任务 " + taskId + " 发生异常: " + e.getMessage());
            } finally {
                // 任务完成或被取消后，从管理列表中移除
                runningTasks.remove(taskId);
                System.out.println("任务 " + taskId + " 已从管理列表移除。");
            }
        });

        runningTasks.put(taskId, future);
        return taskId;
    }

    /**
     * 取消指定ID的任务
     * @param taskId 任务ID
     * @return 如果任务被成功取消或已完成/不存在，返回true；否则返回false
     */
    public boolean cancelTask(String taskId) {
        Future<?> future = runningTasks.get(taskId);
        if (future != null) {
            // 尝试取消任务。true表示如果任务正在运行，则中断其线程
            boolean cancelled = future.cancel(true);
            if (cancelled) {
                System.out.println("已尝试取消任务: " + taskId);
                // 立即从管理列表中移除，或者等待finally块自行移除
                // runningTasks.remove(taskId);
            } else {
                System.out.println("任务 " + taskId + " 无法取消 (可能已完成或已取消)。");
            }
            return cancelled;
        }
        System.out.println("未找到任务ID: " + taskId);
        return false;
    }

    /**
     * 获取任务状态
     * @param taskId 任务ID
     * @return 任务状态字符串
     */
    public String getTaskStatus(String taskId) {
        Future<?> future = runningTasks.get(taskId);
        if (future == null) {
            return "NOT_FOUND";
        }
        if (future.isDone()) {
            return future.isCancelled() ? "CANCELLED" : "COMPLETED";
        }
        return "RUNNING";
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/tasks")
public class TaskController {

    @Autowired
    private LongRunningTaskService taskService;

    /**
     * 提交一个长时间运行的任务
     * POST /api/tasks/run/{timeToRun}
     * @param timeToRun 模拟任务运行的秒数
     * @return 任务ID
     */
    @PostMapping("/run/{timeToRun}")
    public ResponseEntity<String> runTask(@PathVariable int timeToRun) {
        if (timeToRun <= 0) {
            return ResponseEntity.badRequest().body("timeToRun 必须大于0.");
        }
        String taskId = taskService.submitTask(timeToRun);
        return ResponseEntity.ok("任务已提交，ID: " + taskId);
    }

    /**
     * 取消指定ID的任务
     * POST /api/tasks/cancel/{taskId}
     * @param taskId 要取消的任务ID
     * @return 取消结果信息
     */
    @PostMapping("/cancel/{taskId}")
    public ResponseEntity<String> cancelTask(@PathVariable String taskId) {
        if (taskService.cancelTask(taskId)) {
            return ResponseEntity.ok("任务 " + taskId + " 的取消请求已发送。");
        } else {
            return ResponseEntity.badRequest().body("无法取消任务 " + taskId + " (可能不存在或已完成)。");
        }
    }

    /**
     * 获取指定ID任务的状态
     * GET /api/tasks/status/{taskId}
     * @param taskId 任务ID
     * @return 任务状态
     */
    @GetMapping("/status/{taskId}")
    public ResponseEntity<String> getTaskStatus(@PathVariable String taskId) {
        String status = taskService.getTaskStatus(taskId);
        return ResponseEntity.ok("任务 " + taskId + " 状态: " + status);
    }
}