Spring Boot定时任务超时管理与优雅中断Spring Boot的@Scheduled注解极大简化了定时任务的开发，但在面对长时间运行或可能“挂起”的任务时，默认行为可能导致问题。本文将深入探讨如何为Spring Boot定时任务设置超时机制，确保任务在规定时间内完成，并能在超时时被优雅中断，从而避免资源耗尽或任务堆积。

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class TextFilter {    
    @Scheduled(fixedDelay = 5 * 60 * 1000) // 5分钟
    public void updateSensitiveWords() {
        System.out.println("开始执行敏感词更新任务...");
        // 模拟一个耗时操作
        try {
            Thread.sleep(3 * 60 * 1000); // 假设正常耗时3分钟
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 重新设置中断标志
            System.out.println("敏感词更新任务被中断！");
            return;
        }
        System.out.println("敏感词更新任务完成。");
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

@Configuration
@EnableScheduling // 启用Spring的定时任务功能
public class SchedulingConfig {

    @Bean
    public ThreadPoolTaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(10); // 设置线程池大小，根据任务数量和并发需求调整
        scheduler.setThreadNamePrefix("MyScheduledTask-"); // 设置线程名称前缀，方便日志追踪
        scheduler.setWaitForTasksToCompleteOnShutdown(true); // 在应用关闭时等待所有任务完成
        scheduler.setAwaitTerminationSeconds(60); // 最多等待60秒让任务完成

        // 关键设置：当任务被取消时，尝试从工作队列中移除并中断其线程。
        // 对于实现超时中断至关重要，因为Future.cancel(true)依赖此设置来中断线程。
        scheduler.setRemoveOnCancelPolicy(true); 

        scheduler.initialize(); // 初始化调度器
        return scheduler;
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.stereotype.Component;

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

@Component
public class TimedTextFilter {

    @Autowired
    private ThreadPoolTaskScheduler taskScheduler; // 注入我们自定义的调度器

    private final long TASK_TIMEOUT_MINUTES = 2; // 任务超时时间：2分钟

    @Scheduled(fixedDelay = 5 * 60 * 1000) // 每5分钟（在前一个任务结束后）触发一次
    public void triggerUpdateSensitiveWordsWithTimeout() {
        System.out.println("----------------------------------------");
        System.out.println("定时任务触发：开始执行敏感词更新任务（带超时控制）...");

        // 将实际的业务逻辑封装成一个 Callable
        Callable<Void> actualTask = () -> {
            System.out.println("子任务开始执行：实际敏感词更新逻辑...");
            try {
                // 模拟一个耗时操作，可能正常完成，也可能超时
                long simulatedDuration = 3 * 60 * 1000; // 模拟耗时3分钟，超过2分钟的超时
                // long simulatedDuration = 1 * 60 * 1000; // 模拟耗时1分钟，在超时内完成

                for (int i = 0; i < simulatedDuration / 1000; i++) {
                    Thread.sleep(1000); // 每秒检查一次中断
                    if (Thread.currentThread().isInterrupted()) {
                        System.out.println("子任务：检测到中断信号，提前退出！");
                        return null; // 任务被中断，直接返回
                    }
                }
                System.out.println("子任务完成：实际敏感词更新逻辑执行完毕。");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 重新设置中断标志
                System.out.println("子任务：捕获到InterruptedException，任务被中断！");
            } catch (Exception e) {
                System.err.println("子任务执行异常: " + e.getMessage());
            }
            return null;
        };

        // 提交任务到调度器，并获取 Future
        Future<Void> future = taskScheduler.submit(actualTask);

        try {
            // 等待任务完成，设置超时时间
            future.get(TASK_TIMEOUT_MINUTES, TimeUnit.MINUTES);
            System.out.println("主调度器：敏感词更新任务在规定时间内完成。");
        } catch (TimeoutException e) {
            // 任务超时了
            System.err.println("主调度器：敏感词更新任务超时（超过 " + TASK_TIMEOUT_MINUTES + " 分钟）！");
            // 尝试取消任务。true表示如果任务正在运行，尝试中断其线程。
            boolean cancelled = future.cancel(true); 
            System.err.println("主调度器：任务取消尝试结果: " + (cancelled ? "成功" : "失败或已完成"));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 重新设置中断标志
            System.err.println("主调度器：当前线程被中断，任务未完成。");
            future.cancel(true); // 尝试取消子任务
        } catch (Exception e) {
            System.err.println("主调度器：任务执行过程中发生其他异常: " + e.getMessage());
            future.cancel(true); // 发生异常也尝试取消子任务
        } finally {
            System.out.println("定时任务结束：敏感词更新任务（带超时控制）处理完毕。");
            System.out.println("----------------------------------------");
        }
    }
}