爱站程序员基地前言
异步调用 对应的是 同步调用，同步调用 指程序按照 定义顺序 依次执行，每一行程序都必须等待上一行程序执行完成之后才能执行；异步调用 指程序在顺序执行时，不等待 异步调用的语句 返回结果 就执行后面的程序。
正文
1. 环境准备
利用 SpringInitializer 创建一个 gradle 项目 spring-boot-async-task，创建时添加相关依赖。得到的初始 build.gradle 如下：
buildscript {ext {springBootVersion = \'2.0.3.RELEASE\'}repositories {mavenCentral()}dependencies {classpath(\"org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}\")}}apply plugin: \'java\'apply plugin: \'eclipse\'apply plugin: \'org.springframework.boot\'apply plugin: \'io.spring.dependency-management\'group = \'io.ostenant.springboot.sample\'version = \'0.0.1-SNAPSHOT\'sourceCompatibility = 1.8repositories {mavenCentral()}dependencies {compile(\'org.springframework.boot:spring-boot-starter-web\')compileOnly(\'org.projectlombok:lombok\')testCompile(\'org.springframework.boot:spring-boot-starter-test\')}
在 SpringBoot 入口类上配置 @EnableAsync 注解开启异步处理。
@SpringBootApplication@EnableAsyncpublic class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}}
创建任务抽象类 AbstractTask，并分别配置三个任务方法 doTaskOne()， doTaskTwo()， doTaskThree()。
public abstract class AbstractTask {private static Random random = new Random();public void doTaskOne() throws Exception {out.println(\"开始做任务一\");long start = currentTimeMillis();sleep(random.nextInt(10000));long end = currentTimeMillis();out.println(\"完成任务一，耗时：\" + (end - start) + \"毫秒\");}public void doTaskTwo() throws Exception {out.println(\"开始做任务二\");long start = currentTimeMillis();sleep(random.nextInt(10000));long end = currentTimeMillis();out.println(\"完成任务二，耗时：\" + (end - start) + \"毫秒\");}public void doTaskThree() throws Exception {out.println(\"开始做任务三\");long start = currentTimeMillis();sleep(random.nextInt(10000));long end = currentTimeMillis();out.println(\"完成任务三，耗时：\" + (end - start) + \"毫秒\");}}
2. 同步调用
下面通过一个简单示例来直观的理解什么是同步调用：
- 定义 Task 类，继承 AbstractTask，三个处理函数分别模拟三个执行任务的操作，操作消耗时间随机取（ 10 秒内）。
@Componentpublic class Task extends AbstractTask {}
- 在 单元测试 用例中，注入 Task 对象，并在测试用例中执行 doTaskOne()， doTaskTwo()， doTaskThree() 三个方法。
@RunWith(SpringRunner.class)@SpringBootTestpublic class TaskTest {@Autowiredprivate Task task;@Testpublic void testSyncTasks() throws Exception {task.doTaskOne();task.doTaskTwo();task.doTaskThree();}}
- 执行单元测试，可以看到类似如下输出：
开始做任务一完成任务一，耗时：4059毫秒开始做任务二完成任务二，耗时：6316毫秒开始做任务三完成任务三，耗时：1973毫秒
任务一、任务二、任务三顺序的执行完了，换言之 doTaskOne()， doTaskTwo()， doTaskThree() 三个方法顺序的执行完成。
3. 异步调用
上述的 同步调用 虽然顺利的执行完了三个任务，但是可以看到 执行时间比较长，若这三个任务本身之间 不存在依赖关系，可以 并发执行 的话，同步调用在 执行效率 方面就比较差，可以考虑通过 异步调用 的方式来 并发执行。
- 创建 AsyncTask类，分别在方法上配置 @Async 注解，将原来的 同步方法 变为 异步方法。
@Componentpublic class AsyncTask extends AbstractTask {@Asyncpublic void doTaskOne() throws Exception {super.doTaskOne();}@Asyncpublic void doTaskTwo() throws Exception {super.doTaskTwo();}@Asyncpublic void doTaskThree() throws Exception {super.doTaskThree();}}
- 在 单元测试 用例中，注入 AsyncTask 对象，并在测试用例中执行 doTaskOne()， doTaskTwo()， doTaskThree() 三个方法。
@RunWith(SpringRunner.class)@SpringBootTestpublic class AsyncTaskTest {@Autowiredprivate AsyncTask task;@Testpublic void testAsyncTasks() throws Exception {task.doTaskOne();task.doTaskTwo();task.doTaskThree();}}
- 执行单元测试，可以看到类似如下输出：
开始做任务三开始做任务一开始做任务二
如果反复执行单元测试，可能会遇到各种不同的结果，比如：
-
没有任何任务相关的输出
-
有部分任务相关的输出
- 乱序的任务相关的输出
原因是目前 doTaskOne()， doTaskTwo()， doTaskThree() 这三个方法已经 异步执行 了。主程序在 异步调用 之后，主程序并不会理会这三个函数是否执行完成了，由于没有其他需要执行的内容，所以程序就 自动结束 了，导致了 不完整 或是 没有输出任务 相关内容的情况。
注意：@Async所修饰的函数不要定义为static类型，这样异步调用不会生效。
4. 异步回调
为了让 doTaskOne()， doTaskTwo()， doTaskThree() 能正常结束，假设我们需要统计一下三个任务 并发执行 共耗时多少，这就需要等到上述三个函数都完成动用之后记录时间，并计算结果。
那么我们如何判断上述三个 异步调用 是否已经执行完成呢？我们需要使用 Future<T> 来返回 异步调用 的 结果。
- 创建 AsyncCallBackTask 类，声明 doTaskOneCallback()， doTaskTwoCallback()， doTaskThreeCallback() 三个方法，对原有的三个方法进行包装。
@Componentpublic class AsyncCallBackTask extends AbstractTask {@Asyncpublic Future<String> doTaskOneCallback() throws Exception {super.doTaskOne();return new AsyncResult<>(\"任务一完成\");}@Asyncpublic Future<String> doTaskTwoCallback() throws Exception {super.doTaskTwo();return new AsyncResult<>(\"任务二完成\");}@Asyncpublic Future<String> doTaskThreeCallback() throws Exception {super.doTaskThree();return new AsyncResult<>(\"任务三完成\");}}
在 单元测试 用例中，注入 AsyncCallBackTask 对象，并在测试用例中执行 doTaskOneCallback()， doTaskTwoCallback()， doTaskThreeCallback() 三个方法。循环调用 Future 的 isDone() 方法等待三个 并发任务 执行完成，记录最终执行时间。
@RunWith(SpringRunner.class)@SpringBootTestpublic class AsyncCallBackTaskTest {@Autowiredprivate AsyncCallBackTask task;@Testpublic void testAsyncCallbackTask() throws Exception {long start = currentTimeMillis();Future<String> task1 = task.doTaskOneCallback();Future<String> task2 = task.doTaskTwoCallback();Future<String> task3 = task.doTaskThreeCallback();// 三个任务都调用完成，退出循环等待while (!task1.isDone() || !task2.isDone() || !task3.isDone()) {sleep(1000);}long end = currentTimeMillis();out.println(\"任务全部完成，总耗时：\" + (end - start) + \"毫秒\");}}
看看都做了哪些改变：
-
在测试用例一开始记录开始时间；
-
在调用三个异步函数的时候，返回Future类型的结果对象；
-
在调用完三个异步函数之后，开启一个循环，根据返回的Future对象来判断三个异步函数是否都结束了。若都结束，就结束循环；若没有都结束，就等1秒后再判断。
- 跳出循环之后，根据结束时间 – 开始时间，计算出三个任务并发执行的总耗时。
执行一下上述的单元测试，可以看到如下结果：
开始做任务一开始做任务三开始做任务二完成任务二，耗时：4882毫秒完成任务三，耗时：6484毫秒完成任务一，耗时：8748毫秒任务全部完成，总耗时：9043毫秒
可以看到，通过 异步调用，让任务一、任务二、任务三 并发执行，有效的 减少了程序的 运行总时间。
5. 定义线程池
在上述操作中，创建一个 线程池配置类 TaskConfiguration ，并配置一个 任务线程池对象 taskExecutor。
@Configurationpublic 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 创建了一个 线程池，同时设置了以下这些参数：
-
核心线程数：线程池创建时候初始化的线程数
-
最大线程数：线程池最大的线程数，只有在缓冲队列满了之后，才会申请超过核心线程数的线程
-
缓冲队列：用来缓冲执行任务的队列
-
允许线程的空闲时间：当超过了核心线程之外的线程，在空闲时间到达之后会被销毁
-
线程池名的前缀：可以用于定位处理任务所在的线程池
- 线程池对拒绝任务的处理策略：这里采用CallerRunsPolicy策略，当线程池没有处理能力的时候，该策略会直接在execute方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务
创建 AsyncExecutorTask类，三个任务的配置和 AsyncTask 一样，不同的是 @Async 注解需要指定前面配置的 线程池的名称 taskExecutor。
@Componentpublic class AsyncExecutorTask extends AbstractTask {@Async(\"taskExecutor\")public void doTaskOne() throws Exception {super.doTaskOne();out.println(\"任务一，当前线程：\" + currentThread().getName());}@Async(\"taskExecutor\")public void doTaskTwo() throws Exception {super.doTaskTwo();out.println(\"任务二，当前线程：\" + currentThread().getName());}@Async(\"taskExecutor\")public void doTaskThree() throws Exception {super.doTaskThree();out.println(\"任务三，当前线程：\" + currentThread().getName());}}
- 在 单元测试 用例中，注入 AsyncExecutorTask 对象，并在测试用例中执行 doTaskOne()， doTaskTwo()， doTaskThree() 三个方法。
@RunWith(SpringRunner.class)@SpringBootTestpublic class AsyncExecutorTaskTest {@Autowiredprivate AsyncExecutorTask task;@Testpublic void testAsyncExecutorTask() throws Exception {task.doTaskOne();task.doTaskTwo();task.doTaskThree();sleep(30 * 1000L);}}
执行一下上述的 单元测试，可以看到如下结果：
开始做任务一开始做任务三开始做任务二完成任务二，耗时：3905毫秒任务二，当前线程：taskExecutor-2完成任务一，耗时：6184毫秒任务一，当前线程：taskExecutor-1完成任务三，耗时：9737毫秒任务三，当前线程：taskExecutor-3
执行上面的单元测试，观察到 任务线程池 的 线程池名的前缀 被打印，说明 线程池 成功执行 异步任务！
6. 优雅地关闭线程池
由于在应用关闭的时候异步任务还在执行，导致类似 数据库连接池 这样的对象一并被 销毁了，当 异步任务 中对 数据库 进行操作就会出错。
解决方案如下，重新设置线程池配置对象，新增线程池 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): 该方法用来设置线程池中 任务的等待时间，如果超过这个时间还没有销毁就 强制销毁，以确保应用最后能够被关闭，而不是阻塞住。
小结
本文介绍了在 SpringBoot 中如何使用 @Async 注解配置 异步任务、异步回调任务，包括结合 任务线程池 的使用，以及如何 正确 并 优雅 地关闭 任务线程池。
欢迎关注技术公众号： 零壹技术栈
本帐号将持续分享后端技术干货，包括虚拟机基础，多线程编程，高性能框架，异步、缓存和消息中间件，分布式和微服务，架构学习和进阶等学习资料和文章。
