解决SpringBoot定时任务@Scheduled单线程问题

小贤java

已于 2023-09-08 08:21:34 修改

阅读量5.4w

点赞数 15

分类专栏： Spring Spring Boot 文章标签： spring spring boot java 面试后端

于 2023-09-06 00:17:18 首次发布

本文链接：https://blog.csdn.net/imwucx/article/details/132692263

版权

Spring 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

Spring Boot

1 篇文章 0 订阅

订阅专栏

结论：我的项目是单线程

如何实现为多线程？

3.2 是否前一个任务执行完才执行后一个任务

3.3 前一个任务抛异常后下一个任务是否还能正常执行？

一、环境

Jdk8
SpringBoot项目
应用启动类中添加@EnableScheduling
方法中添加@Scheduled来实现定时任务

二、为什么要知道它是多线程还是单线程？

2.1 背景

我的项目中

用ThreadLocal的工具类 DistributeUtil
两个定时任务，都使用了 DistributeUtil

考虑到 ThreadLocal 可能会造成内在泄漏问题，每个定时任务都加了try catch finnaly最后清里ThreadLocal即调它的 remove()方法。

2.2 疑问

在提交代码之前，我突然想到，如果是Scheduled单线程，使用不当的话，会不会造成第一个任务执行完，第二个执行的时候，DistributeUtil里的ThreadLocal 被第一个任务清空而没有数据，造成业务逻辑错误，而造成线上不可原谅的BUG？

为了弄清楚这个问题，我做了如下实验，来验证Scheduled是单线程还是多线程的。

三、验证

3.1 是单线程还是多线程

创建一个ThreadLocal处理消息工具类

/**
 * 测试@Scheduled是单线程还是多线程 <br/>
 *
 * @author 小贤java
 */
public class DistributeUtil {

    private static ThreadLocal<String> local = new ThreadLocal<>();

    public static void set(String msg) {
        local.set(msg);
    }

    public static String get() {
        return local.get();
    }

    public static void remote() {
        local.remove();
    }
}

创建一个测试Job类

/**
 * @author 小贤java
 */
@Component
@Slf4j
public class QwTaskJob {


    @Scheduled(cron = "0/10 * * * * *")
    public void test1() {

        DistributeUtil.set("添加一条test1数据。。");
        log.info("添加一条test1数据。。。 threadName:" + Thread.currentThread().getName());
    }

    @Scheduled(cron = "0/3 * * * * *")
    public void test2() {
        log.error("获取test1中的数据 ： " + DistributeUtil.get() + " threadName:" + Thread.currentThread().getName());
    }
}

启动项目，看test2是否能读取到test1写进去的数据，运行结果如下图：

运行结果来看，任务test2中确实能获取到任务test1中设置进去的数据，并且打印的线程信息跟test1任务打印的一样。说明任务test1和任务test2是在同一个线程中执行的。

结论：本项目环境（默认）下@Scheduled是单线程的

3.2 是否前一个任务执行完才执行后一个任务

修改代码让test1睡眠30秒钟，如下

/**
 * @author 小贤java
 */
@Component
@Slf4j
public class QwTaskJob {


    @Scheduled(cron = "0/10 * * * * *")
    public void test1() throw Exception{

        DistributeUtil.set("添加一条test1数据。。");
        log.info("添加一条test1数据。。。 threadName:" + Thread.currentThread().getName());
        Thread.sleep(30000);
    }

    @Scheduled(cron = "0/3 * * * * *")
    public void test2() {
        log.error("获取test1中的数据 ： " + DistributeUtil.get() + " threadName:" + Thread.currentThread().getName());
    }
}

启动项目，查看运行结果如下：

说明任务test2是在任务test1执行完之后（30秒之后）才开始执行的

结论：本项目环境下@Scheduled配置的前一个任务执行完下一个任务才开始执行

3.3 前一个任务抛异常后下一个任务是否还能正常执行？

修改代码如下

/**
 * @author 小贤java
 */
@Component
@Slf4j
public class QwTaskJob {


    @Scheduled(cron = "0 40 * * * *")
    public void test1() throws Exception{

        DistributeUtil.set("添加一条test1数据。。");
        log.info("添加一条test1数据。。。 threadName:" + Thread.currentThread().getName());

        throw new RuntimeException("抛一个异常看test2是否还能正常执行");
    }

    @Scheduled(cron = "10 40 * * * *")
    public void test2() {
        log.error("获取test1中的数据 ： " + DistributeUtil.get() + " threadName:" + Thread.currentThread().getName());
    }
}

项目跑起来，查结果如下：

如图所示，test1抛异常之后任务test2还是可以正常运行的。

结果：前一个任务异常，不会影响下一个任务的执行。

四、影响

如果前一个任务阻塞了，后续的任务将一直阻塞着。从而产生很严重的后果。如果是银行业跑批结算任务，就非常严重了。当然也有一些跑批是严格要求顺序执行的。

为了解决某些场景下因任务test1阻塞使test2不受到影响，把@Scheduled的管理线程池修改为多线程。

五、实现多线程

修改代码如下

/**
 * @author 小贤java
 */
@Component
@Slf4j
public class QwTaskJob {


    @Scheduled(cron = "20 59 * * * *")
    public void test1() throws Exception{

        DistributeUtil.set("添加一条test1数据。。");
        log.info("我是任务test1： 添加一条test1数据。。。 threadName:" + Thread.currentThread().getName());

        Thread.sleep(30000);
    }

    @Scheduled(cron = "30 59 * * * *")
    public void test2() {
        log.error("我是任务test2： 获取test1中的数据 ： " + DistributeUtil.get() + " threadName:" + Thread.currentThread().getName());
    }
}

启动项目，查看运行结果如下图：

任务test1还是睡眠30秒，如果图所示，任务test2执行周期一到就执行了，而且任务test1和任务test2是由不同的线程执行的。

5.1 多线程配置：配置task线程池

在application.yml文件中添加spring.task.scheduling.pool.size = 2（本测试中有两个任务同时执行，size值大于等于2即可）

5.2 多线程配置：配置类

配置类一：

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

/**
 * Scheduled异步配置 <br/>
 *
 * @author 小贤java
 * @date 2023/9/6 19:26:21
 */
@Configuration
public class ScheduleConfig {

    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        // 设置线程池大小
        taskScheduler.setPoolSize(Runtime.getRuntime().availableProcessors() * 2);
        return taskScheduler;
    }
}

配置类二：

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

import java.util.concurrent.ScheduledThreadPoolExecutor;

/**
 * Scheduled异步配置 <br/>
 *
 * @author 小贤java
 * @date 2023/9/6 19:27:16
 */
@Configuration
public class ScheduleConfig implements SchedulingConfigurer {

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(
                new ScheduledThreadPoolExecutor(Runtime.getRuntime().availableProcessors() * 2)
        );
    }
}

以上两种实现方法均为修改线程池大小，来实现每个任务在独立的线程中执行。（点击查阅更多线程池）对于同一个任务的执行是同步的，同一个任务中只有上一个执行周期完成，才会执行下一个执行周期。若想实现异步任务，可添加异步注解。

5.3 多线程注解：异步注解

在应用启动类中添加@EnableAsync
在任务方法上添加@Async

修改代码如下：

/**
 * @author 小贤java
 */
@Component
@Slf4j
public class QwTaskJob {


    @Async
    @Scheduled(cron = "0/3 * * * * ?")
    public void test1() {
        try {
            // 让它休息30秒，来测试下一个执行周是否开始执行
            log.info("让它休息30秒，来测试下一个执行周是否开始执行");
            Thread.sleep(30000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

启动项目，查看运行结果如下图：