如何为 Spring Boot @Scheduled 定时任务实现超时控制Spring Boot 的 @Scheduled 注解是实现周期性任务的强大工具，但它本身不提供直接的超时（timeout）属性来强制中断长时间运行的任务。本文将深入探讨如何在 Spring Boot 中为 @Scheduled 任务设置超时机制，包括配置底层的 ThreadPoolTaskScheduler 以及更直接地在

@Scheduled(fixedDelay = 5 * 60 * 1000, timeout = 2 * 60 * 1000) // 这是一个错误的示例，@Scheduled 不支持 timeout 属性
public void updateSensitiveWords() {
    // 耗时操作
}

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 // 启用调度功能
public class SchedulingConfig {

    @Bean
    public ThreadPoolTaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(5); // 设置线程池大小，例如允许5个任务并发执行
        scheduler.setThreadNamePrefix("my-scheduled-task-"); // 设置线程名称前缀
        scheduler.setWaitForTasksToCompleteOnShutdown(true); // 在应用关闭时等待任务完成
        scheduler.setAwaitTerminationSeconds(60); // 最长等待60秒
        // scheduler.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 拒绝策略，可选
        return scheduler;
    }
}

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

import java.util.concurrent.*;

@Component
public class TimedTaskExample {

    // 建议使用单独的ExecutorService来处理内部的耗时操作，避免阻塞调度器的线程池
    private final ExecutorService taskExecutor = Executors.newSingleThreadExecutor(); // 或 Executors.newFixedThreadPool(1);

    @Scheduled(fixedDelay = 5 * 60 * 1000) // 每5分钟执行一次，基于上次任务完成时间
    public void updateSensitiveWordsWithTimeout() {
        long timeoutSeconds = 2 * 60; // 设置任务超时时间为2分钟

        System.out.println("Scheduled task started at: " + System.currentTimeMillis());

        // 将实际的业务逻辑封装在一个 Callable 中
        Callable<String> actualTask = () -> {
            try {
                System.out.println("  Actual task logic started.");
                // 模拟一个耗时操作，例如网络请求、大量数据处理等
                // 如果这个操作是可中断的，当线程被中断时，它会抛出 InterruptedException
                Thread.sleep(3 * 60 * 1000); // 模拟耗时3分钟，超过2分钟的超时时间
                System.out.println("  Actual task logic finished.");
                return "Task Completed Successfully";
            } catch (InterruptedException e) {
                System.out.println("  Actual task logic interrupted!");
                // 重新设置中断标志，以便更高层的代码可以检测到中断
                Thread.currentThread().interrupt();
                return "Task Interrupted";
            } catch (Exception e) {
                System.err.println("  Actual task logic failed: " + e.getMessage());
                throw e; // 抛出异常
            }
        };

        Future<String> future = taskExecutor.submit(actualTask);

        try {
            String result = future.get(timeoutSeconds, TimeUnit.SECONDS); // 等待任务完成，设置超时
            System.out.println("Task execution result: " + result);
        } catch (TimeoutException e) {
            System.err.println("Task timed out after " + timeoutSeconds + " seconds. Attempting to cancel...");
            // 如果任务超时，尝试中断任务线程
            boolean cancelled = future.cancel(true); // true 表示尝试中断正在执行的线程
            System.err.println("Task cancellation status: " + cancelled);
        } catch (InterruptedException e) {
            System.err.println("Scheduled task was interrupted while waiting for internal task completion.");
            Thread.currentThread().interrupt();
        } catch (ExecutionException e) {
            System.err.println("Error during task execution: " + e.getCause().getMessage());
        } finally {
            System.out.println("Scheduled task finished at: " + System.currentTimeMillis());
        }
    }

    // 在应用程序关闭时，确保关闭内部的 ExecutorService
    // 这是一个生命周期管理方法，Spring Boot 应用通常不需要手动调用，
    // 因为 Spring 会管理 @Bean 或 @Component 的生命周期。
    // 但如果 taskExecutor 不是一个 Spring Bean，则需要手动管理。
    // @PreDestroy
    // public void destroy() {
    //     if (taskExecutor != null && !taskExecutor.isShutdown()) {
    //         taskExecutor.shutdownNow(); // 尝试立即关闭
    //     }
    // }
}