Spring Boot定时任务超时控制与中断策略

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 ScheduledTaskConfig {

    /**
     * 配置自定义的 ThreadPoolTaskScheduler
     * @return ThreadPoolTaskScheduler实例
     */
    @Bean
    public ThreadPoolTaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(10); // 设置线程池核心线程数，根据任务量和并发需求调整
        scheduler.setThreadNamePrefix("my-scheduled-task-"); // 设置线程名称前缀，方便日志追踪
        scheduler.setWaitForTasksToCompleteOnShutdown(true); // 在应用关闭时，等待所有任务完成
        scheduler.setAwaitTerminationSeconds(60); // 最长等待60秒，确保任务完成
        // 设置当任务被取消时，是否从队列中移除。对于超时中断的场景，有助于清理。
        scheduler.setRemoveOnCancelPolicy(true); 
        scheduler.initialize(); // 初始化调度器
        return scheduler;
    }
}

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

import java.util.concurrent.*;

@Component
public class TextFilter {

    // 建议将ExecutorService作为Bean管理，避免每次任务执行都创建新的线程池
    private final ExecutorService taskExecutor = Executors.newSingleThreadExecutor();

    /**
     * 假设的敏感词更新服务
     */
    private void doUpdateSensitiveWordsLogic() throws InterruptedException {
        System.out.println("开始更新敏感词...");
        // 模拟耗时操作，例如网络请求或数据库查询
        long startTime = System.currentTimeMillis();
        try {
            // 模拟业务逻辑，可能会很耗时
            for (int i = 0; i < 10; i++) {
                // 在耗时操作中检查中断状态，这是实现可中断的关键
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("敏感词更新任务被中断，提前退出。");
                    throw new InterruptedException("Task interrupted");
                }
                TimeUnit.SECONDS.sleep(1); // 模拟每一步耗时1秒
                System.out.println("敏感词更新中... " + (i + 1) + "秒");
            }
            System.out.println("敏感词更新完成！");
        } finally {
            System.out.println("敏感词更新逻辑执行耗时: " + (System.currentTimeMillis() - startTime) + "ms");
            // 确保资源在此处清理，即使被中断
        }
    }

    @Scheduled(fixedDelay = 5 * 60 * 1000) // 每5分钟（上次任务结束后）执行一次
    public void updateSensitiveWordsWithTimeout() {
        // 定义任务的超时时间，例如2分钟
        long timeoutMinutes = 2;
        System.out.println("\n定时任务 [updateSensitiveWordsWithTimeout] 开始执行，预计超时时间: " + timeoutMinutes + "分钟");

        Future<?> future = taskExecutor.submit(() -> {
            try {
                doUpdateSensitiveWordsLogic();
            } catch (InterruptedException e) {
                // 捕获到中断异常，说明任务被外部中断了
                Thread.currentThread().interrupt(); // 重新设置中断标志
                System.err.println("内部任务被中断: " + e.getMessage());
            } catch (Exception e) {
                System.err.println("内部任务执行异常: " + e.getMessage());
            }
        });

        try {
            // 等待任务完成，设置超时时间
            future.get(timeoutMinutes, TimeUnit.MINUTES);
            System.out.println("定时任务 [updateSensitiveWordsWithTimeout] 正常完成。");
        } catch (TimeoutException e) {
            // 任务超时，尝试中断任务
            boolean cancelled = future.cancel(true); // true表示尝试中断线程
            System.err.println("定时任务 [updateSensitiveWordsWithTimeout] 执行超时 (" + timeoutMinutes + "分钟)，尝试中断: " + cancelled);
        } catch (InterruptedException e) {
            // 当前线程被中断（例如，外部停止了Spring应用）
            Thread.currentThread().interrupt();
            System.err.println("定时任务 [updateSensitiveWordsWithTimeout] 自身被中断: " + e.getMessage());
        } catch (ExecutionException e) {
            // 任务执行过程中抛出异常
            System.err.println("定时任务 [updateSensitiveWordsWithTimeout] 执行过程中出现异常: " + e.getCause().getMessage());
        } finally {
            // 确保 future 被清理，如果需要的话
            // 注意：taskExecutor 应该在应用关闭时统一管理其生命周期
        }
    }
}