重学SpringBoot系列之异步任务与定时任务
Posted 大忽悠爱忽悠
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了重学SpringBoot系列之异步任务与定时任务相关的知识，希望对你有一定的参考价值。
重学SpringBoot系列之异步任务与定时任务
实现Async异步任务
环境准备
在 Spring Boot 入口类上配置 @EnableAsync 注解开启异步处理。
创建任务抽象类 AbstractTask，并分别配置三个任务方法 doTaskOne()，doTaskTwo()，doTaskThree()。
public abstract class AbstractTask
private static Random random = new Random();
public void doTaskOne() throws Exception
System.out.println("开始做任务一");
long start = currentTimeMillis();
sleep(random.nextInt(10000));
long end = currentTimeMillis();
System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");
public void doTaskTwo() throws Exception
System.out.println("开始做任务二");
long start = currentTimeMillis();
sleep(random.nextInt(10000));
long end = currentTimeMillis();
System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");
public void doTaskThree() throws Exception
System.out.println("开始做任务三");
long start = currentTimeMillis();
sleep(random.nextInt(10000));
long end = currentTimeMillis();
System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");
同步调用
下面通过一个简单示例来直观的理解什么是同步调用：
- 定义
Task类，继承AbstractTask，三个处理函数分别模拟三个执行任务的操作，操作消耗时间随机取（10 秒内）。
@Component
public class SyncTask extends AbstractTask
- 在
单元测试用例中，注入SyncTask对象，并在测试用例中执行doTaskOne()，doTaskTwo()，doTaskThree()三个方法。
@RunWith(SpringRunner.class)
@SpringBootTest
public class TaskTest
@Autowired
private SyncTask task;
@Test
public void testSyncTasks() throws Exception
task.doTaskOne();
task.doTaskTwo();
task.doTaskThree();
执行单元测试，可以看到类似如下输出：
开始做任务一
完成任务一，耗时：6720毫秒
开始做任务二
完成任务二，耗时：6604毫秒
开始做任务三
完成任务三，耗时：9448毫秒
任务一、任务二、任务三顺序的执行完了，换言之 doTaskOne()，doTaskTwo()，doTaskThree() 三个方法按调用顺序的先后执行完成。
异步调用
上述的 同步调用 虽然顺利的执行完了三个任务，但是可以看到 执行时间比较长，若这三个任务本身之间 不存在依赖关系，可以 并发执行 的话，同步调用在 执行效率 方面就比较差，可以考虑通过 异步调用 的方式来 并发执行。
- 在
Application启动类上面加上@EnableAsync - 创建
AsyncTask类，分别在方法上配置@Async注解，将原来的同步方法变为异步方法。
@Component
public class SyncTask extends AbstractTask
@Async
@Override
public void doTaskOne() throws Exception
super.doTaskOne();
@Async
@Override
public void doTaskTwo() throws Exception
super.doTaskTwo();
@Async
@Override
public void doTaskThree() throws Exception
super.doTaskThree();
- 在
单元测试用例中，注入AsyncTask对象，并在测试用例中执行doTaskOne()，doTaskTwo()，doTaskThree()三个方法。
@Autowired
private AsyncTask asyncTask;
@Test
public void testAsyncTasks() throws Exception
asyncTask.doTaskOne();
asyncTask.doTaskTwo();
asyncTask.doTaskThree();
- 执行单元测试，可以看到类似如下输出：
开始做任务三
开始做任务一
开始做任务二
如果反复执行单元测试，可能会遇到各种不同的结果，比如：
- 没有任何任务相关的输出
- 有部分任务相关的输出
- 乱序的任务相关的输出
原因是目前 doTaskOne()，doTaskTwo()，doTaskThree() 这三个方法已经 异步并发执行 了。主程序在 异步调用 之后，主程序并不会理会这三个函数是否执行完成了，由于没有其他需要执行的内容，所以程序就 自动结束 了，导致了任务 不完整 或是 没有输出 相关内容的情况。
注意：@Async所修饰的函数不要定义为static类型，这样异步调用不会生效。
异步回调
为了让 doTaskOne()，doTaskTwo()，doTaskThree() 能正常结束，假设我们需要统计一下三个任务 并发执行 共耗时多少，这就需要等到上述三个函数都完成动用之后记录时间，并计算结果。
那么我们如何判断上述三个 异步调用 是否已经执行完成呢？我们需要使用 Future<T> 来返回 异步调用 的 结果。
- 创建
AsyncCallBackTask类，声明doTaskOneCallback()，doTaskTwoCallback()，doTaskThreeCallback()三个方法，对原有的三个方法进行包装。
@Component
public class AsyncCallBackTask extends AbstractTask
@Async
public Future<String> doTaskOneCallback() throws Exception
super.doTaskOne();
return new AsyncResult<>("任务一完成");
@Async
public Future<String> doTaskTwoCallback() throws Exception
super.doTaskTwo();
return new AsyncResult<>("任务二完成");
@Async
public Future<String> doTaskThreeCallback() throws Exception
super.doTaskThree();
return new AsyncResult<>("任务三完成");
- 在
单元测试用例中，注入AsyncCallBackTask对象，并在测试用例中执行doTaskOneCallback()，doTaskTwoCallback()，doTaskThreeCallback()三个方法。循环调用Future的isDone()方法等待三个并发任务执行完成，记录最终执行时间。
@Autowired
private AsyncCallBackTask asyncCallBackTask;
@Test
public void testAsyncCallbackTask() throws Exception
long start = currentTimeMillis();
Future<String> task1 = asyncCallBackTask.doTaskOneCallback();
Future<String> task2 = asyncCallBackTask.doTaskTwoCallback();
Future<String> task3 = asyncCallBackTask.doTaskThreeCallback();
// 三个任务都调用完成，退出循环等待
while (!task1.isDone() || !task2.isDone() || !task3.isDone())
sleep(1000);
long end = currentTimeMillis();
System.out.println("任务全部完成，总耗时：" + (end - start) + "毫秒");
看看都做了哪些改变：
- 在测试用例一开始记录开始时间；
- 在调用三个异步函数的时候，返回Future类型的结果对象；
- 在调用完三个异步函数之后，开启一个循环，根据返回的Future对象来判断三个异步函数是否都结束了。若都结束，就结束循环；若没有都结束，就等1秒后再判断。
- 跳出循环之后，根据结束时间 - 开始时间，计算出三个任务并发执行的总耗时。
执行一下上述的单元测试，可以看到如下结果：
开始做任务三
开始做任务一
开始做任务二
完成任务二，耗时：2572毫秒
完成任务一，耗时：7333毫秒
完成任务三，耗时：7647毫秒
任务全部完成，总耗时：8013毫秒
可以看到，通过 异步调用，让任务一、任务二、任务三 并发执行，有效的 减少 了程序的 运行总时间。
为异步任务规划线程池
Spring Boot任务线程池
线程池的作用
- 防止资源占用无限的扩张
- 调用过程省去资源的创建和销毁所占用的时间
在上一节中，我们的一个异步任务打开了一个线程，完成后销毁。在高并发环境下，不断的分配新资源，可能导致系统资源耗尽。所以为了避免这个问题，我们为异步任务规划一个线程池。当然，如果没有配置线程池的话，springboot会自动配置一个ThreadPoolTaskExecutor 线程池到bean当中。
# 核心线程数
spring.task.execution.pool.core-size=8
# 最大线程数
spring.task.execution.pool.max-size=16
# 空闲线程存活时间
spring.task.execution.pool.keep-alive=60s
# 是否允许核心线程超时
spring.task.execution.pool.allow-core-thread-timeout=true
# 线程队列数量
spring.task.execution.pool.queue-capacity=100
# 线程关闭等待
spring.task.execution.shutdown.await-termination=false
spring.task.execution.shutdown.await-termination-period=
# 线程名称前缀
spring.task.execution.thread-name-prefix=task-
自定义线程池
有的时候，我们希望将系统内的一类任务放到一个线程池，另一类任务放到另外一个线程池，所以使用Spring Boot自带的任务线程池就捉襟见肘了。下面介绍自定义线程池的方法。
创建一个 线程池配置类TaskConfiguration ，并配置一个 任务线程池对象taskExecutor。
@Configuration
public class TaskConfiguration
@Bean("taskExecutor")
public Executor taskExecutor()
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(20);
executor.setQueueCapacity(200);
executor.setKeepAliveSeconds(60);
executor.setThreadNamePrefix("taskExecutor-");
executor.setRejectedExecutionHandler(new CallerRunsPolicy());
return executor;
上面我们通过使用 ThreadPoolTaskExecutor 创建了一个 线程池，同时设置了以下这些参数：
Reject策略预定义有四种：
- AbortPolicy，用于被拒绝任务的处理程序，它将抛出RejectedExecutionException。
- CallerRunsPolicy，用于被拒绝任务的处理程序，它直接在execute方法的调用线程中运行被拒绝的任务。
- DiscardOldestPolicy，用于被拒绝任务的处理程序，它放弃最旧的未处理请求，然后重试
execute。 - DiscardPolicy，用于被拒绝任务的处理程序，默认情况下它将丢弃被拒绝的任务。
创建 AsyncExecutorTask类，三个任务的配置和 AsyncTask 一样，不同的是 @Async 注解需要指定前面配置的 线程池的名称taskExecutor。
@Component
public class AsyncExecutorTask extends AbstractTask
@Async("taskExecutor")
public Future<String> doTaskOneCallback() throws Exception
super.doTaskOne();
System.out.println("任务一，当前线程：" + Thread.currentThread().getName());
return new AsyncResult<>("任务一完成");
@Async("taskExecutor")
public Future<String> doTaskTwoCallback() throws Exception
super.doTaskTwo();
System.out.println("任务二，当前线程：" + Thread.currentThread().getName());
return new AsyncResult<>("任务二完成");
@Async("taskExecutor")
public Future<String> doTaskThreeCallback() throws Exception
super.doTaskThree();
System.out.println("任务三，当前线程：" + Thread.currentThread().getName());
return new AsyncResult<>("任务三完成");
在 单元测试 用例中，注入 AsyncExecutorTask 对象，并在测试用例中执行 doTaskOne()，doTaskTwo()，doTaskThree() 三个方法。
@SpringBootTest
public class AsyncExecutorTaskTest
@Autowired
private AsyncExecutorTask task;
@Test
public void testAsyncExecutorTask() throws Exception
task.doTaskOneCallback();
task.doTaskTwoCallback();
task.doTaskThreeCallback();
sleep(30 * 1000L);
执行一下上述的 单元测试，可以看到如下结果：
开始做任务一
开始做任务三
开始做任务二
完成任务二，耗时：3905毫秒
任务二，当前线程：taskExecutor-2
完成任务一，耗时：6184毫秒
任务一，当前线程：taskExecutor-1
完成任务三，耗时：9737毫秒
任务三，当前线程：taskExecutor-3
执行上面的单元测试，观察到 任务线程池 的 线程池名的前缀 被打印，说明 线程池 成功执行 异步任务！
优雅地关闭线程池
由于在应用关闭的时候异步任务还在执行，导致类似
数据库连接池这样的对象一并被 销毁了，当异步任务中对数据库进行操作就会出错。
解决方案如下，重新设置线程池配置对象，新增线程池 setWaitForTasksToCompleteOnShutdown() 和 setAwaitTerminationSeconds() 配置：
@Bean("taskExecutor")
public Executor taskExecutor()
ThreadPoolTaskScheduler executor = new ThreadPoolTaskScheduler();
executor.setPoolSize(20);
executor.setThreadNamePrefix("taskExecutor-");
executor.setWaitForTasksToCompleteOnShutdown(true);
executor.setAwaitTerminationSeconds(60);
return executor;
-
setWaitForTasksToCompleteOnShutdown(true): 该方法用来设置 线程池关闭 的时候 等待
所有任务都完成后，再继续 销毁 其他的 Bean，这样这些 异步任务 的 销毁 就会先于 数据库连接池对象 的销毁。 -
setAwaitTerminationSeconds(60): 该方法用来设置线程池中
任务的等待时间，如果超过这个时间还没有销毁就 强制销毁，以确保应用最后能够被关闭，而不是阻塞住。
通过@Scheduled实现定时任务
开启定时任务方法
Scheduled定时任务是Spring boot自身提供的功能，所以不需要引入Maven依赖包
在项目入口main方法上加注解
@EnableScheduling //开启定时任务
不同定时方式的解析
1.fixedDelay和fixedRate，单位是毫秒，它们的区别就是：
- fixedRate就是每隔多长时间执行一次。(开始------->X时间------>再开始)。如果间隔时间小于任务执行时间，上一次任务执行完成下一次任务就立即执行。如果间隔时间大于任务执行时间，就按照每隔X时间运行一次。
- 而fixedDelay是当任务执行完毕后一段时间再次执行。（开始—>结束(隔一分钟)开始----->结束）。上一次执行任务未完成，下一次任务不会开始
cron表达式：灵活
举例说明
- 第一位，表示秒，取值0-59
- 第二位，表示分，取值0-59
- 第三位，表示小时，取值0-23
- 第四位，日期天/日，取值1-31
- 第五位，日期月份，取值1-12
- 第六位，星期，取值1-7，星期一，星期二…，注：不是第1周，第二周的意思，另外：1表示星期天，2表示星期一。
- 第七位，年份，可以留空，取值1970-2099
cron中，还有一些特殊的符号，含义如下：
- (*)星号：可以理解为每的意思，每秒，每分，每天，每月，每年…
- (?)问号：问号只能出现在日期和星期这两个位置。
- (-)减号：表达一个范围，如在小时字段中使用“10-12”，则表示从10到12点，即10,11,12
- (,)逗号：表达一个列表值，如在星期字段中使用“1,2,4”，则表示星期一，星期二，星期四
- (/)斜杠：如：x/y，x是开始值，y是步长，比如在第一位（秒）0/15就是，从0秒开始，每15秒，最后就是0，15，30，45，60 另：/y，等同于0/y
cron表达式在线：http://cron.qqe2.com/
实现定时任务
@Component
public class ScheduledJobs
//表示方法执行完成后5秒再开始执行
@Scheduled(fixedDelay=5000)
public void fixedDelayJob() throws InterruptedException
System.out.println("fixedDelay 开始:" + new Date());
Thread.sleep(10 * 1000);
System.out.println("fixedDelay 结束:" + new Date());
//表示每隔3秒
@Scheduled(fixedRate=3000)
public void fixedRateJob()throws InterruptedException
System.out.println("===========fixedRate 开始:" + new Date());
Thread.sleep(5 * 1000);
System.out.println("===========fixedRate 结束:" + new Date());
//表示每隔10秒执行一次
@Scheduled(cron=以上是关于重学SpringBoot系列之异步任务与定时任务的主要内容，如果未能解决你的问题，请参考以下文章