spring boot自定义线程池进行异步调用
大型超市里，通常都不止一个收银台，因为这样可以提高效率，设想一下，如果某一天，其他的收银员都请假了，只剩下一个收银台，看着那漫长的排队大军，是不是很捉急，很无奈。这就是异步存在的意义了。
当我们需要异步调用的时候，很容易就想到多线程的方式，先创建线程池，然后实现 Runnable 或者 Callable 接口来创建对象，然后将对象放在线程池中去执行。除了这个，spring 提供了更简单粗暴的方式，这就是本章的主角： @Async 。
如果直接使用 @Async，那么默认就是使用 SimpleAsyncTaskExecutor 线程池，由于 SimpleAsyncTaskExecutor 不限制并发线程而且不重用线程，那么直接使用是有风险的，所以本章直接介绍通过自定义线程池来使用 @Async 达到异步调用的目的。
1. 创建默认线程池
@EnableAsync
@Configuration
public class ThreadPoolConfig {
@Bean("taskExecutor")
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(16);
executor.setMaxPoolSize(16);
executor.setQueueCapacity(1024);
executor.setKeepAliveSeconds(60);
executor.setThreadNamePrefix("taskExecutor-");
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
return executor;
}
}
@EnableAsync 注解主要是为了扫描范围包下的所有 @Async 注解
2.创建异步任务类
@Component
public class AsyncTask {
/**
* task 1
*/
@Async("taskExecutor")
public void task1() {
System.out.println("task1 开始执行");
long startTime = System.currentTimeMillis();
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
}
System.out.println("task1 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
}
/**
* task 1
*/
@Async("taskExecutor")
public void task2() {
System.out.println("task2 开始执行");
long startTime = System.currentTimeMillis();
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
}
System.out.println("task2 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
}
}
3.异步调用类
@RestController
public class AsyncController {
@Autowired
private AsyncTask asyncTask;
@GetMapping("/async")
public void test(){
System.out.println("test 开始执行");
long startTime = System.currentTimeMillis();
asyncTask.task1();
asyncTask.task2();
System.out.println("test 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
}
}
打印结果：
test 开始执行
test 执行结束，耗时：6
task1 开始执行
task2 开始执行
task1 执行结束，耗时：1000
task2 执行结束，耗时：1000
4.有返回值的异步任务
以上的 task1 和 task2 任务是没有返回值，如果碰到需要获取任务结果怎么办，这时候就可以用到 Future 了。
先给 task1 和 task2 添加返回值：
/**
* task 1
*/
@Async("taskExecutor")
public Future<String> task1() {
System.out.println("task1 开始执行");
long startTime = System.currentTimeMillis();
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
}
System.out.println("task1 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
return new AsyncResult<>("task1 success");
}
/**
* task 2
*/
@Async("taskExecutor")
public Future<String> task2() {
System.out.println("task2 开始执行");
long startTime = System.currentTimeMillis();
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
}
System.out.println("task2 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
return new AsyncResult<>("task2 success");
}
然后进行调用，并获取结果：
@GetMapping("/async")
public void test() throws ExecutionException, InterruptedException {
System.out.println("test 开始执行");
long startTime = System.currentTimeMillis();
Future<String> result1 = asyncTask.task1();
Future<String> result2 = asyncTask.task2();
System.out.println("test 执行结果，result1：" + result1.get() + ", result2:" + result2.get());
System.out.println("test 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
}
打印结果如下：
test 开始执行
task1 开始执行
task2 开始执行
task1 执行结束，耗时：1001
task2 执行结束，耗时：1001
test 执行结果，result1：task1 success, result2:task2 success
test 执行结束，耗时：1016
可以看到 task1 和 task2 是异步执行的，并且成功获取到返回结果。
5.注意事项
如果将在异步任务类中直接调用 @Async 修饰的方法，那么异步调用将会失效。
举个栗子：
在 AsyncTask 类中直接调用 task1 和 task2 方法：
public void test(){
System.out.println("test 开始执行");
long startTime = System.currentTimeMillis();
this.task1();
this.task2();
System.out.println("test 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
}
然后在 AsyncController 中调用 test 方法：
@GetMapping("/async")
public void test(){
asyncTask.test();
}
打印结果如下：
test 开始执行
task1 开始执行
task1 执行结束，耗时：1000
task2 开始执行
task2 执行结束，耗时：1001
test 执行结束，耗时：2001
可以明显看出，task1 和 task2 不是异步执行的。原因就是调用 task1 和 task2 方法的是 AsyncTask 对象本身，而不是 spring 启动的时候为其创建的代理对象，没有经过 spring 容器。如果要解决这个问题，就按照这个思路，创建一个代理对象即可。
在 AsyncTask 中先通过自动装配获取 applicationContext 对象，然后通过 applicationContext 获取 AsyncTask 的代理对象，通过代理对象来调用 task1 和 task2 ：
@Component
public class AsyncTask {
@Autowired
private ApplicationContext applicationContext;
public void test(){
System.out.println("test 开始执行");
long startTime = System.currentTimeMillis();
applicationContext.getBean(AsyncTask.class).task1();
applicationContext.getBean(AsyncTask.class).task2();
System.out.println("test 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
}
/**
* task 1
*/
@Async("taskExecutor")
public Future<String> task1() {
System.out.println("task1 开始执行");
long startTime = System.currentTimeMillis();
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
}
System.out.println("task1 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
return new AsyncResult<>("task1 success");
}
/**
* task 2
*/
@Async("taskExecutor")
public Future<String> task2() {
System.out.println("task2 开始执行");
long startTime = System.currentTimeMillis();
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
}
System.out.println("task2 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
return new AsyncResult<>("task2 success");
}
}
调用方法：
@GetMapping("/async")
public void test() throws ExecutionException, InterruptedException {
System.out.println("test 开始执行");
asyncTask.test();
long startTime = System.currentTimeMillis();
System.out.println("test 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
}
打印结果：
test 开始执行
test 开始执行
test 执行结束，耗时：6
test 执行结束，耗时：0
task1 开始执行
task2 开始执行
task1 执行结束，耗时：1000
task2 执行结束，耗时：1000
可以看到 task1 和 task2 是异步执行的，该思路是生效的。
