SpringBoot定时任务里的多线程

  • 提示
  • 前言
  • 遇到的问题
  • 验证与解决
    • 验证
      • 单线程执行单任务
        • 分析
        • 代码及结果
      • 单线程执行多任务
    • 解决
      • 实现单任务的多线程
        • 为每个任务创建一个子线程
      • 解决多任务的多线程
        • 设定固定容量线程池
        • 动态设定容量线程池
        • 固定线程池和动态线程池的选择
  • 简单总结
  • 借鉴及引用

提示

本文并不涉及cron表达式，而是关注于执行定时任务的线程。

前言

我们在搭建系统的时候，不可避免地要用到定时任务，注解为 @Scheduled(cron = "cron表达式")，就像闹钟那样，每天定时执行叫醒你起来上早八或者上班的任务。

遇到的问题

在使用过程中，遇到了不少问题。

  1. 在定时任务中默认使用单线程的方式来执行定时任务。


也就是任务1、2、3之中只能有任一一个在执行，而无法同时进行。

比如在任务1任务2都是从0秒开始运行，那么在0秒的时候本来预期是两者一起运行，也就是以下这样：

但由于默认是单线程，所以它就可能变成了以下两种情况：
先执行任务1在执行任务2

或者相反

同时执行的任务，在单线程的情况下随机执行一个。

所以你可以看到单线程对于多个任务而言，有很多不方便的地方。比如某个任务耗费时间比较长，那么其他的定时任务就必须要等它执行结束才能继续执行。又或者有的任务直接挂掉了，导致所有的定时任务都无法执行。

  1. 在多线程的定时任务中，每个任务只分配到一个线程。

在上面的讨论中，我们注意到单线程的弊端，那么自然有解决办法。那就是多线程执行定时任务，多线程执行任务就是以下这样：

但大家有没有发现一个问题，就是单个线程能应付得了单个任务吗？

举个简单的例子：我们上面的提到过的耗费时间比较长的问题。

比如我们任务1从0秒开始每5秒执行一次，但是其任务执行时间要7秒。那么就可能导致什么问题？大家可以想一下。
3

2

1

你觉得是这样？

但其实是这样：

单线程应付不了单个任务的时候，就可能导致我们的任务并不会按照我们的预期去执行。

如上面那样由于上一次任务的执行时间大于我的定时间隔时间，导致我漏掉下一次任务，又或者某次执行挂掉卡住了导致后续定时任务无法执行。

怎么解决上述的问题？
其实这个问题，可以具体化到如何让任务的每次执行互不影响？
3

2

1

答案揭晓：多线程。

为任务的每次执行分配一个线程，使得每次任务的执行两两独立，互不影响。也就是一下这样：

验证与解决

下面我们就来在项目中验证上述中提到的相关问题，请注意下面的验证顺序与上面提到的问题顺序的略有不同。

验证

以下内容仅仅验证上面的叙述在SpringBoot环境中的定时任务是否准确。

单线程执行单任务

当任务的执行时间，大于你设定的时间时，单线程、单个定时任务如何执行？

以上面提到过的任务一的执行举例：从0秒开始每5秒钟执行一次，但是你的任务每次执行时间需要7秒，请设想一下在一分钟内它最终执行多少次？

分析

第一次执行完是7秒，那么此时已经过了5秒的那个点，所以下一次到10秒才会执行。也就是对应秒数到达0 ，10 ，20，30，40，50的时候才会执行，总共执行6次。也就是上图中的

代码及结果

来看以下定时任务代码：

//从0开始 每五秒执行一次@Scheduled(cron ="0/5 * * * * *")public void testTread4() throws InterruptedException {//在一分钟内执行if(DateUtil.formatStr(new Date()).compareTo("2023-05-16 17:06") >= 0&& DateUtil.formatStr(new Date()).compareTo("2023-05-16 17:07") < 0) {//睡眠7秒钟Thread.sleep(7000);//执行结束时间System.out.println("执行任务" + DateUtil.formatStr(new Date()));}}

执行结果（注意：这里的输出时间为定时任务执行结束时间而非开始时间）：

很明显符合我们预期的结果，也就是单线程情况下，如果在执行任务期间还要执行新的任务，那么该新任务就会被忽略。

单线程执行多任务

在单线程执行多任务情况下，如果某个任务执行过久，由于它是单线程，所以会导致后续任务也被要等待它执行结束，才能继续执行。也就是上图中的


或者

来看以下这段代码的逻辑

//一秒执行一次@Scheduled(cron ="0/1 * * * * *")public void testTread2() {System.out.println("定时任务1 开始"+ DateUtil.formatStr(new Date()));//假设以下是它需要执行的任务内容 以下代码执行时间超过一秒for(int i =0; i < 1000000 * 500;i++) {String str = "diuhfiahiudhfadfjkakhfkjahsjcndjakdjfoiejalkdjfialdjcxkjhaoifkdhjafhdkahjfkdahfaldkjfianvnjvhdhuiehrkahkjdfakhuidhfakjhducian";String result1 = "";result1 = result1 + str.indexOf(i % 125);}System.out.println("定时任务1 结束"+ DateUtil.formatStr(new Date()));}//一秒执行一次@Scheduled(cron ="0/1 * * * * *")public void testTread3() {System.out.println("定时任务2 开始"+ DateUtil.formatStr(new Date()));//假设以下是它需要执行的任务内容 常规时间执行是两秒左右for(int i =0; i < 1000000 * 50;i++) {String str = "diuhfiahiudhfadfjkakhfkjahsjcndjakdjfoiejalkdjfialdjcxkjhaoifkdhjafhdkahjfkdahfaldkjfianvnjvhdhuiehrkahkjdfakhuidhfakjhducian";String result1 = "";result1 = result1 + str.indexOf(i % 125);}System.out.println("定时任务2 结束"+ DateUtil.formatStr(new Date()));}

我们来看下结果：

可以明显看到，当有任务1未执行完时，即使任务2到达执行的时间，也没有执行。

那么，如何让单线程定时任务变成多线程呢？

画外音：忙碌了一整天的鱼师傅回到家中，发现了这个问题，最复杂的问题往往只需要最朴素的解决办法，他打开了csdn…


不好意思，串台了。

解决

这里需要分为两个方面：

  1. 单个任务，多个线程：每次的执行都交给一个新的线程。
    对应我们上面提到的：
  2. 多个定时任务对应多个线程：让每个任务单独分到一个线程。
    也就是上面的这个图

简单来讲，单线程多任务的情况就是，一个定时任务需要多个线程来执行。

多任务多线程就是，多个定时任务需要多个线程来执行。

实现单任务的多线程

将任务的每次执行交给一个新的线程，任务的每次执行独立。

为每个任务创建一个子线程

为每个任务里面的执行内容新建一个子线程。

修改上述代码：

@Scheduled(cron ="0/5 * * * * *")public void testTread4() {//为每一个子任务创建一个新的线程执行 也可以将具体的任务内容封装到一个继承Thread或者实现Runnable接口的类中new Thread(new Runnable() {@Overridepublic void run() {try {//在一分钟内执行if(DateUtil.formatStr(new Date()).compareTo("2023-05-16 17:25") >= 0&& DateUtil.formatStr(new Date()).compareTo("2023-05-16 17:26") < 0) {//睡眠7秒钟Thread.sleep(7000);System.out.println("执行任务" + DateUtil.formatStr(new Date()));}} catch (InterruptedException e) {e.printStackTrace();}}}).start();}

执行结果

//0秒开始执行 执行7秒 07结束执行任务2023-05-16 17:25:07//5秒开始执行 12结束执行任务2023-05-16 17:25:12//10秒开始执行 17结束执行任务2023-05-16 17:25:17执行任务2023-05-16 17:25:22执行任务2023-05-16 17:25:27执行任务2023-05-16 17:25:32执行任务2023-05-16 17:25:37执行任务2023-05-16 17:25:42执行任务2023-05-16 17:25:47执行任务2023-05-16 17:25:52执行任务2023-05-16 17:25:57//25：55秒开始执行 26：02结束执行任务2023-05-16 17:26:02

可以看到执行了12次，并且每个任务的开始时间是00 - 05 - 10 - 15 - .....-55，互不影响，两两独立。

解决多任务的多线程

这个逻辑只需要让每个定时任务各自拥有一个线程，每个定时任务之间独立，你干你的，我干我的，互不影响。

设定固定容量线程池

一种方法是添加配置定时任务的配置类，修改默认的线程池容量（默认为1，也就是单线程）。

新建ScheduleConfig.java配置文件，内容如下：

import org.springframework.context.annotation.Bean;import org.springframework.scheduling.TaskScheduler;import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;import org.springframework.stereotype.Component;@Componentpublic class ScheduleConfig {@Beanpublic TaskScheduler taskScheduler() {//定时任务线程池ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();// 设置线程池大小为10taskScheduler.setPoolSize(10);return taskScheduler;}}

执行结果：

可以看到任务1和任务2同时开始执行，不再出现谁等谁的情况了。

动态设定容量线程池

另一种方法是实现任务调度配置接口 – SchedulingConfigurer ，根据任务数量配置线程池钟线程最大数量，也可以达到上面的效果。

@Component@Configuration@EnableSchedulingpublic class MySchedule//需要实现这个接口implements SchedulingConfigurer {//配置定时任务线程池信息 有多少定时任务就配置多大的线程池 任务中新建的子线程并不由是此线程池里的对象@Overridepublic void configureTasks(ScheduledTaskRegistrar taskRegistrar) {//获取所有方法Method[] methods = MySchedule.class.getMethods();//线程池默认大小10int defaultPoolSize = 10;//实际大小为0int corePoolSize = 0;Assert.notNull(methods , "并无定时任务");if (methods.length > 0) {//遍历所有任务 统计所有带定时任务注解的方法个数for (Method method : methods) {Scheduled annotation = method.getAnnotation(Scheduled.class);if (annotation != null) {corePoolSize++;}}//最小为10if (defaultPoolSize > corePoolSize)corePoolSize = defaultPoolSize;}System.out.println("线程池大小：" + corePoolSize);taskRegistrar.setScheduler(Executors.newScheduledThreadPool(corePoolSize));} //一秒执行一次@Scheduled(cron ="0/1 * * * * *")public void testTread2() {System.out.println("定时任务1 开始"+ DateUtil.formatStr(new Date() , DateUtil.MillisecondPattern));//假设以下是它需要执行的任务内容 以下代码执行时间超过一秒for(int i =0; i < 1000000 * 500;i++) {String str = "diuhfiahiudhfadfjkakhfkjahsjcndjakdjfoiejalkdjfialdjcxkjhaoifkdhjafhdkahjfkdahfaldkjfianvnjvhdhuiehrkahkjdfakhuidhfakjhducian";String result1 = "";result1 = result1 + str.indexOf(i % 125);}System.out.println("定时任务1 结束"+ DateUtil.formatStr(new Date() , DateUtil.MillisecondPattern));}//一秒执行一次@Scheduled(cron ="0/1 * * * * *")public void testTread3() {System.out.println("定时任务2 开始"+ DateUtil.formatStr(new Date() , DateUtil.MillisecondPattern));//假设以下是它需要执行的任务内容 常规时间执行是两秒左右for(int i =0; i < 1000000 * 50;i++) {String str = "diuhfiahiudhfadfjkakhfkjahsjcndjakdjfoiejalkdjfialdjcxkjhaoifkdhjafhdkahjfkdahfaldkjfianvnjvhdhuiehrkahkjdfakhuidhfakjhducian";String result1 = "";result1 = result1 + str.indexOf(i % 125);}System.out.println("定时任务2 结束"+ DateUtil.formatStr(new Date() , DateUtil.MillisecondPattern));}}

执行结果

可以看到两个任务你干你的 我干我的，不再出现，我要等你干完，我才能干的情况。

需要注意的是，这里设定的池是全局通用的，任何定时任务都可以用这个池，而且共用一个。如果存在多个执行定时任务的类，并且每个类中都有上述的构建池的操作，那么会以最后执行的设置池的容量为准。（这个大家可以自己测试一下，输出的时候加上Thread.currentThread().getName()这个 – 获取线程名称，用于区分线程池里的线程即可。）

比如我有两个定时任务类，第一个里面有2个定时任务，第二个里面有18个定时任务：

那么执行的时候MySchedule设置的池大小为10，West01设置的池大小为18。最后各个任务执行的时候，所用到的池大小为18。

如果将West01更改为Aest01，那么最后执行用到的池就是MySchedule里面设置的池容量，大小为10。

因为按照名称排序并且加载，MySchedule的加载排在Aest01之后，West01之前，容量以最后的设置为准。

MySchedule与West01
MySchedule与Aest01

固定线程池和动态线程池的选择

如果你所有的定时任务都在一个类里面，毫无疑问第二种动态线程池就是最佳选择。

但是你有多个定时任务类，选择第一种完全是ok的，但计算估计有点麻烦需要计算一下，设置为多少合理。

简单总结

在文中，我们从简单的原理描述，到验证，再到最后实操；
从默认的单线程执行任务到多线程执行单任务，再到多线程执行多任务。

想必你会觉得“多线程这么爽那还用什么单线程？”但其实多线程的问题也不少，简单对比一下：

  1. 单线程占用资源少，多线程占用资源多。在多线程情况下，如果某些任务执行时间过长，而新的任务又在不断地产生新的进程，将会迅速耗尽计算机资源。
  2. 单线程不需要考虑资源竞争，多线程需要对共享资源做对应的处理。这个比较容易理解。比如买票，有两个售票员卖票，现在只剩下一张票，这时他们同时接到顾客，都告诉顾客有票，但实际操作的时候手速快的那个把票拿走了，那么后者就没有票可卖了。
  3. 单线程日志记录简单、清楚，多线程日志记录混乱。前者是按顺序说话，后者是这里来一句，那里来一句。

就说到这个里了，还是那句话，没有最好的解决方法，只有最合适的解决方法。

借鉴及引用

Java 多线程编程基础(详细)
Springboot @Scheduled定时任务单线程执行问题