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(10 * 1000); // 模拟10秒耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("敏感词更新任务被中断。");
        }
        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 SchedulerConfig {

    /**
     * 配置自定义的ThreadPoolTaskScheduler
     * Spring会自动使用这个Bean来执行所有@Scheduled任务
     *
     * @return 配置好的ThreadPoolTaskScheduler实例
     */
    @Bean
    public ThreadPoolTaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(10); // 设置调度器线程池的核心大小，根据任务数量和并发需求调整
        scheduler.setThreadNamePrefix("my-scheduled-pool-"); // 为线程池中的线程设置前缀，方便日志追踪
        scheduler.setAwaitTerminationSeconds(60); // 在应用关闭时，允许任务在60秒内完成
        scheduler.setWaitForTasksToCompleteOnShutdown(true); // 在应用关闭时，等待所有任务完成
        scheduler.initialize(); // 初始化调度器
        return scheduler;
    }
}

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

import java.util.concurrent.*;

@Component
public class TimedTaskService {

    // 建议为需要超时控制的任务使用一个独立的ExecutorService
    // 这样可以避免长时间运行的任务阻塞主调度器的线程池
    private final ExecutorService taskTimeoutExecutor = Executors.newFixedThreadPool(5); 

    /**
     * 带有超时控制的定时任务
     * 该方法本身由Spring的taskScheduler调度执行
     */
    @Scheduled(fixedDelay = 5 * 60 * 1000) // 每5分钟调度一次，当上次任务完成后开始计时
    public void updateSensitiveWordsWithTimeout() {
        System.out.println("--------------------------------------------------");
        System.out.println("定时任务 [updateSensitiveWordsWithTimeout] 开始执行，时间: " + System.currentTimeMillis());

        final long taskTimeoutMinutes = 2; // 设置任务超时时间为2分钟
        final long taskTimeoutMillis = taskTimeoutMinutes * 60 * 1000;

        // 将实际的耗时操作封装为一个Callable
        Callable<String> actualTask = () -> {
            try {
                System.out.println("  子任务: 模拟敏感词更新操作开始...");
                // 模拟一个耗时操作，例如从远程服务拉取数据
                Thread.sleep(3 * 60 * 1000); // 模拟3分钟的耗时，这将超过2分钟的超时限制
                System.out.println("  子任务: 模拟敏感词更新操作完成。");
                return "敏感词更新成功";
            } catch (InterruptedException e) {
                // 当Future.cancel(true)被调用时，如果任务正在sleep或wait，会抛出InterruptedException
                System.out.println("  子任务: 敏感词更新操作被中断。");
                Thread.currentThread().interrupt(); // 重新设置中断标志
                throw new InterruptedException("任务被中断");
            } catch (Exception e) {
                System.err.println("  子任务: 敏感词更新操作发生异常: " + e.getMessage());
                throw e; // 重新抛出异常，由外部捕获
            }
        };

        // 将Callable提交给独立的ExecutorService
        Future<String> future = taskTimeoutExecutor.submit(actualTask);

        try {
            // 尝试获取任务结果，并设置超时时间
            String result = future.get(taskTimeoutMillis, TimeUnit.MILLISECONDS);
            System.out.println("定时任务 [updateSensitiveWordsWithTimeout] 成功完成，结果: " + result);
        } catch (TimeoutException e) {
            // 任务超时
            System.err.println("定时任务 [updateSensitiveWordsWithTimeout] 超时！已超过 " + taskTimeoutMinutes + " 分钟。尝试中断当前执行。");
            future.cancel(true); // 尝试中断正在执行的任务线程
            // 在这里可以添加日志记录、告警通知等逻辑
        } catch (InterruptedException e) {
            // 当前线程在等待任务结果时被中断
            System.err.println("定时任务 [updateSensitiveWordsWithTimeout] 在等待子任务完成时被中断。");
            Thread.currentThread().interrupt(); // 重新设置中断标志
        } catch (ExecutionException e) {
            // 子任务执行过程中抛出了异常
            System.err.println("定时任务 [updateSensitiveWordsWithTimeout] 子任务执行失败: " + e.getCause().getMessage());
            // 记录子任务的实际异常
        } finally {
            System.out.println("定时任务 [updateSensitiveWordsWithTimeout] 处理结束，时间: " + System.currentTimeMillis());
            System.out.println("--------------------------------------------------");
        }
    }
}