Spring Boot 定时任务 @Scheduled 的多线程使用

本文讲解 Spring Boot 定时任务 @Scheduled 的多线程原理以及如何加入线程池来处理定时任务。

一、@Scheduled 注解简介

@Scheduled 是 Spring 框架中的一个注解，它可以用于配置定时任务，使得方法可以按照规定的时间间隔定时执行。在使用该注解时，我们可以指定任务的执行时间、循环周期、并发数等参数，从而实现定时任务的功能。在 Spring Boot 中，@Scheduled 注解可以直接应用于方法上。

二、@Scheduled 的多线程机制

在 Spring Boot 中，@Scheduled 注解是基 f 于 Java 的 ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 实现的。

当我们配置了一个定时任务后，Spring Boot 会首先创建一个 ScheduledThreadPoolExecutor 线程池，并将定时任务添加到该线程池中等待执行。然后，在指定的时间到来之后，线程池会为该定时任务分配一个线程来执行。如果该定时任务还未执行完毕，在下一个周期到达时，线程池会为该任务再次分配一个线程来执行。通过这种方式，@Scheduled 可以非常方便地实现周期性的定时任务 f 于 Java 的 ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 实现的。

当我们配置了一个定时任务后，Spring Boot 会首先创建一个 ScheduledThreadPoolExecutor 线程池，并将定时任务添加到该线程池中等待执行。然后，在指定的时间到来之后，线程池会为该定时任务分配一个线程来执行。如果该定时任务还未执行完毕，在下一个周期到达时，线程池会为该任务再次分配一个线程来执行。通过这种方式，@Scheduled 可以非常方便地实现周期性的定时任务。

三、@Scheduled 的多线程问题

虽然 @Scheduled 注解非常便捷，但是它也存在一些多线程的问题，主要体现在以下两个方面：

1. 定时任务未执行完毕时，后续任务可能会受到影响

在使用 @Scheduled 注解时，我们很容易忽略一个问题：如果定时任务在执行时，下一个周期的任务已经到了，那么后续任务可能会受到影响。例如，我们定义了一个间隔时间为 5 秒的定时任务 A，在第 1 秒时开始执行，需要执行 10 秒钟。在第 6 秒时，定时任务 A 还没有结束，此时下一个周期的任务 B 已经开始等待执行。如果此时线程池中没有足够的空闲线程，那么定时任务 B 就会被阻塞，无法执行。

1. 多个定时任务并发执行可能导致资源竞争

在某些情况下，我们可能需要编写多个定时任务，这些定时任务可能涉及到共享资源，例如数据库连接、缓存对象等。当多个定时任务同时执行时，就会存在资源竞争的问题，可能会导致数据错误或者系统崩溃。

四、@Scheduled 加入线程池来处理定时任务

为了避免上述问题，可以将 @Scheduled 任务交给线程池进行处理。在 Spring Boot 中，可以通过以下两种方式来将 @Scheduled 任务加入线程池：

1. 使用 @EnableScheduling + @Configuration 配置 ThreadPoolTaskScheduler

@Configuration@EnableSchedulingpublic class TaskSchedulerConfig {    @Bean    public TaskScheduler taskScheduler() {        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();        scheduler.setPoolSize(10);        scheduler.initialize();        return scheduler;    }}

在上述代码中，我们通过配置 ThreadPoolTaskScheduler 来创建一个线程池，并使用 @EnableScheduling 注解将定时任务开启。其中，setPoolSize 方法可以设置线程池的大小，默认为 1。

1. 使用 ThreadPoolTaskExecutor

@Configuration@EnableSchedulingpublic class TaskExecutorConfig {    @Bean    public ThreadPoolTaskExecutor taskExecutor() {        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();        executor.setCorePoolSize(10);        executor.setMaxPoolSize(50);        executor.setQueueCapacity(1000);        executor.setKeepAliveSeconds(60);        executor.setThreadNamePrefix("task-executor-");        return executor;    }}

在上述代码中，我们通过配置 ThreadPoolTaskExecutor 来创建一个线程池，并使用 @EnableScheduling 注解将定时任务开启。其中 setCorePoolSize、setMaxPoolSize、setQueueCapacity、setKeepAliveSeconds 等方法可以用于配置线程池的大小和任务队列等参数。

五、@Scheduled 详细分析

在 Spring Boot 中，@Scheduled 注解是基于 Java 的 ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 实现的。当我们配置了一个定时任务后，Spring Boot 会首先创建一个 ScheduledThreadPoolExecutor 线程池，并将定时任务添加到该线程池中等待执行。然后，在指定的时间到来之后，线程池会为该定时任务分配一个线程来执行。如果该定时任务还未执行完毕，在下一个周期到达时，线程池会为该任务再次分配一个线程来执行。通过这种方式，@Scheduled 可以非常方便地实现周期性的定时任务。

虽然 @Scheduled 注解非常便捷，但是它也存在一些多线程的问题，主要体现在以下两个方面：

5.1 定时任务未执行完毕时，后续任务可能会受到影响

在使用 @Scheduled 注解时，我们很容易忽略一个问题：如果定时任务在执行时，下一个周期的任务已经到了，那么后续任务可能会受到影响。例如，我们定义了一个间隔时间为 5 秒的定时任务 A，在第 1 秒时开始执行，需要执行 10 秒钟。在第 6 秒时，定时任务 A 还没有结束，此时下一个周期的任务 B 已经开始等待执行。如果此时线程池中没有足够的空闲线程，那么定时任务 B 就会被阻塞，无法执行。

解决方案：

针对上述问题，我们可以采用以下两种方案来解决：

方案一：修改线程池大小

为了避免因为线程池中线程数量不足引起的问题，我们可以对线程池进行配置，提高线程池的大小，从而确保有足够的空闲线程来处理定时任务。

例如，我们可以在 application.properties 或 application.yml 或者使用 @EnableScheduling + @Configuration 来配置线程池大小：

spring.task.scheduling.pool.size=20

5.2 多个定时任务并发执行可能导致资源竞争

在某些情况下，我们可能需要编写多个定时任务，这些定时任务可能涉及到共享资源，例如数据库连接、缓存对象等。当多个定时任务同时执行时，就会存在资源竞争的问题，可能会导致数据错误或者系统崩溃。

解决方案：

为了避免由于多个定时任务并发执行导致的资源竞争问题，我们可以采用以下两种方案来解决：

方案一：使用锁机制

锁机制是一种常见的解决多线程并发访问共享资源的方式。在 Java 中，我们可以使用 synchronized 关键字或者 Lock 接口来实现锁机制。

例如，下面是一个使用 synchronized 关键字实现锁机制的示例：

private static Object lockObj = new Object();
@Scheduled(fixedDelay = 1000)public void doSomething(){    synchronized(lockObj){        // 定时任务要执行的内容    }}

在上述代码中，我们定义了一个静态对象 lockObj，用来保护共享资源。在定时任务执行时，我们使用 synchronized 关键字对 lockObj 进行加锁，从而确保多个定时任务不能同时访问共享资源。

方案二：使用分布式锁

除了使用传统的锁机制外，还可以使用分布式锁来解决资源竞争问题。分布式锁是一种基于分布式系统的锁机制，它可以不依赖于单个 JVM 实例，从而能够保证多个定时任务之间的资源访问不会冲突。

在 Java 开发中，我们可以使用 ZooKeeper、Redis 等分布式系统来实现分布式锁机制。例如，使用 Redis 实现分布式锁的示例代码如下：

@Autowiredprivate RedisTemplate redisTemplate;
@Scheduled(fixedDelay = 1000)public void doSomething(){    String lockKey = "lock:key";    String value = UUID.randomUUID().toString();    Boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey, value, 5L, TimeUnit.SECONDS);    if(result){        try{            // 定时任务要执行的内容        }finally{            redisTemplate.delete(lockKey);        }    }}

在上述代码中，我们使用 Redis 实现了分布式锁机制。具体而言，我们在定时任务执行时，首先向 Redis 中写入一个键值对，然后检查是否成功写入。如果成功写入，则表示当前定时任务获得了锁，可以执行接下来的操作。在定时任务执行完毕后，我们再从 Redis 中删除该键值对，释放锁资源。

六、总结

通过以上的分析，我们可以了解到：虽然 @Scheduled 注解能够非常方便地实现定时任务的功能，但是它也存在一些多线程的问题。为此，需要注意到这些问题，并采取相应的措施来避免它们的出现。在实际开发中，可以结合使用线程池、异步线程池、锁机制、分布式锁等方式，达到最佳的效果。

作者：Cosolar

链接：https://juejin.cn/post/7224275138664251451

来源：稀土掘金