SpringBoot定时任务里的多线程
- 提示
- 前言
- 遇到的问题
- 验证与解决
- 验证
- 单线程执行单任务
- 分析
- 代码及结果
- 单线程执行多任务
- 解决
- 实现单任务的多线程
- 为每个任务创建一个子线程
- 解决多任务的多线程
- 设定固定容量线程池
- 动态设定容量线程池
- 固定线程池和动态线程池的选择
- 简单总结
- 借鉴及引用
提示
本文并不涉及cron表达式，而是关注于执行定时任务的线程。
前言
我们在搭建系统的时候，不可避免地要用到定时任务，注解为 @Scheduled(cron = "cron表达式")，就像闹钟那样，每天定时执行叫醒你起来上早八或者上班的任务。
遇到的问题
在使用过程中，遇到了不少问题。
- 在定时任务中
默认使用单线程的方式来执行定时任务。
也就是任务1、2、3之中只能有任一一个在执行，而无法同时进行。
比如在任务1任务2都是从0秒开始运行，那么在0秒的时候本来预期是两者一起运行，也就是以下这样：
但由于默认是单线程，所以它就可能变成了以下两种情况：
先执行任务1在执行任务2
或者相反
同时执行的任务，在单线程的情况下随机执行一个。
所以你可以看到单线程对于多个任务而言，有很多不方便的地方。比如某个任务耗费时间比较长，那么其他的定时任务就必须要等它执行结束才能继续执行。又或者有的任务直接挂掉了，导致所有的定时任务都无法执行。
- 在
多线程的定时任务中，每个任务只分配到一个线程。
在上面的讨论中，我们注意到单线程的弊端，那么自然有解决办法。那就是多线程执行定时任务，多线程执行任务就是以下这样：
但大家有没有发现一个问题，就是单个线程能应付得了单个任务吗？
举个简单的例子：我们上面的提到过的耗费时间比较长的问题。
比如我们任务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…
不好意思，串台了。
解决
这里需要分为两个方面：
单个任务，多个线程：每次的执行都交给一个新的线程。
对应我们上面提到的：
多个定时任务对应多个线程：让每个任务单独分到一个线程。
也就是上面的这个图
简单来讲，单线程多任务的情况就是，一个定时任务需要多个线程来执行。
多任务多线程就是，多个定时任务需要多个线程来执行。
实现单任务的多线程
将任务的每次执行交给一个新的线程，任务的每次执行独立。
为每个任务创建一个子线程
为每个任务里面的执行内容新建一个子线程。
修改上述代码：
@Scheduled(cron ="0/5 * * * * *")
public void testTread4() {
//为每一个子任务创建一个新的线程执行 也可以将具体的任务内容封装到一个继承Thread或者实现Runnable接口的类中
new Thread(new Runnable() {
@Override
public 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;
@Component
public class ScheduleConfig {
@Bean
public TaskScheduler taskScheduler() {
//定时任务线程池
ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
// 设置线程池大小为10
taskScheduler.setPoolSize(10);
return taskScheduler;
}
}
执行结果：
可以看到任务1和任务2同时开始执行，不再出现谁等谁的情况了。
动态设定容量线程池
另一种方法是实现任务调度配置接口 – SchedulingConfigurer ，根据任务数量配置线程池钟线程最大数量，也可以达到上面的效果。
@Component
@Configuration
@EnableScheduling
public class MySchedule
//需要实现这个接口
implements SchedulingConfigurer {
//配置定时任务线程池信息 有多少定时任务就配置多大的线程池 任务中新建的子线程并不由是此线程池里的对象
@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
//获取所有方法
Method[] methods = MySchedule.class.getMethods();
//线程池默认大小10
int defaultPoolSize = 10;
//实际大小为0
int corePoolSize = 0;
Assert.notNull(methods , "并无定时任务");
if (methods.length > 0) {
//遍历所有任务 统计所有带定时任务注解的方法个数
for (Method method : methods) {
Scheduled annotation = method.getAnnotation(Scheduled.class);
if (annotation != null) {
corePoolSize++;
}
}
//最小为10
if (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的，但计算估计有点麻烦需要计算一下，设置为多少合理。
简单总结
在文中，我们从简单的原理描述，到验证，再到最后实操；
从默认的单线程执行任务到多线程执行单任务，再到多线程执行多任务。
想必你会觉得“多线程这么爽那还用什么单线程？”但其实多线程的问题也不少，简单对比一下：
- 单线程占用资源
少，多线程占用资源多。在多线程情况下，如果某些任务执行时间过长，而新的任务又在不断地产生新的进程，将会迅速耗尽计算机资源。 单线程不需要考虑资源竞争，多线程需要对共享资源做对应的处理。这个比较容易理解。比如买票，有两个售票员卖票，现在只剩下一张票，这时他们同时接到顾客，都告诉顾客有票，但实际操作的时候手速快的那个把票拿走了，那么后者就没有票可卖了。- 单线程
日志记录简单、清楚，多线程日志记录混乱。前者是按顺序说话，后者是这里来一句，那里来一句。
就说到这个里了，还是那句话，没有最好的解决方法，只有最合适的解决方法。
借鉴及引用
Java 多线程编程基础(详细)
Springboot @Scheduled定时任务单线程执行问题
