SpringBoot使用@Scheduled实现定时任务

百里浅暮 / 2023-08-07 / 原文

SpringBoot 实现定时任务很简单，只需要使用@Scheduled注解即可，但是该注解是实现的定时任务默认是单线程的，也就意味着多个定时任务执行时就可能导致线程堵塞，延缓定时任务的执行。所以在需要的时候，我们可以设置一个线程池去执行定时任务。

在启动类上加入@EnableScheduling注解

// 启用定时任务
@EnableScheduling 
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

@Component
public class Task {
    Logger logger = LoggerFactory.getLogger(Task.class);
	// 每五秒执行一次
    @Scheduled(cron = "0/5 * * * * ?")
    public void taskTestA() throws InterruptedException {
        logger.info("A:");
        TimeUnit.SECONDS.sleep(20);
    }
  
    // 每十秒执行一次
    @Scheduled(cron = "0/10 * * * * ?")
    public void taskTestB() {
        logger.info("B:");
    }
}

结果：

由图可知，首先这两个定时任务都是单线程的，但是当定时A执行了一次后，由于定时A中有个休眠20秒，然后执行定时任务B，所以线程A第二次执行在25秒后才执行，这就是由于@Scheduled定时任务是单线程，造成的线程堵塞，导致定时任务推迟执行。

@Scheduled + 配置线程池

（一）在配置文件添加线程池的配置

// 若不设置默认为单线程，这里设置使用线程池，大小为4
spring：
  task:
    scheduling:
      pool:
        size: 4

（二）配置类配置线程池

通过实现SchedulingConfigurer接口来将定时线程池放入



import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

@Configuration
public class TaskConfig implements SchedulingConfigurer {

    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler executor = new ThreadPoolTaskScheduler();
        executor.setPoolSize(10);
        executor.setThreadNamePrefix("task-thread");
        //设置饱和策略
        //CallerRunsPolicy：线程池的饱和策略之一，当线程池使用饱和后，直接使用调用者所在的线程来执行任务；如果执行程序已关闭，则会丢弃该任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }

	//配置@Scheduled 定时器所使用的线程池
	//配置任务注册器：ScheduledTaskRegistrar 的任务调度器
    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
    	//可配置两种类型：TaskScheduler、ScheduledExecutorService
        //scheduledTaskRegistrar.setScheduler(taskScheduler());
        //只可配置一种类型：taskScheduler
        scheduledTaskRegistrar.setTaskScheduler(taskScheduler());
    }

}

线程池的饱和策略：

如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了，线程池会执行饱和策略。

ThreadPoolExecutor.AbortPolicy：抛出 RejectedExecutionException来拒绝新任务的处理。
ThreadPoolExecutor.CallerRunsPolicy：当线程池使用饱和后，直接使用调用者所在的线程来执行任务；如果执行程序已关闭，则会丢弃该任务。
ThreadPoolExecutor.DiscardPolicy：不处理新任务，直接丢弃掉。
ThreadPoolExecutor.DiscardOldestPolicy：此策略将丢弃最早的未处理的任务请求。