详解SpringBoot中的异步调用@Async

也想出现在这里？点击联系我~

如何开启异步调用

在SpringBoot中，只需要给方法加上@Async注解，就能将同步方法变为异步调用。

首先在启动类上添加@EnableAsync，即开启异步调用。

1. /**
2. *@authorqcy
3. */
4. @SpringBootApplication
5. @EnableAsync
6. publicclassAsyncApplication{
8. publicstaticvoidmain(String[]args){
9. SpringApplication.run(AsyncApplication.class,args);
10. }
12. }

在需要异步调用的方法上加上@Async注解

1. packagecom.yang.async;
3. importlombok.extern.slf4j.Slf4j;
4. importorg.springframework.scheduling.annotation.Async;
5. importorg.springframework.scheduling.annotation.AsyncResult;
6. importorg.springframework.stereotype.Component;
8. importjava.util.concurrent.Future;
9. importjava.util.concurrent.FutureTask;
11. /**
12. *@authorqcy
13. *@create2020/09/0914:01:35
14. */
15. @Slf4j
16. @Component
17. publicclassTask{
19. @Async
20. publicvoidmethod1(){
21. log.info("method1开始,执行线程为"+Thread.currentThread().getName());
22. try{
23. Thread.sleep(2000);
24. }catch(InterruptedExceptione){
25. e.printStackTrace();
26. }
27. log.info("method1结束");
28. }
30. @Async
31. publicvoidmethod2(){
32. log.info("method2开始,执行线程为"+Thread.currentThread().getName());
33. try{
34. Thread.sleep(3000);
35. }catch(InterruptedExceptione){
36. e.printStackTrace();
37. }
38. log.info("method2结束");
39. }
42. }

测试一下：

1. @SpringBootTest
2. @Slf4j
3. publicclassAsyncApplicationTests{
5. @Autowired
6. Tasktask;
8. @Test
9. publicvoidtestAsyncWithVoidReturn()throwsInterruptedException{
10. log.info("main线程开始");
12. task.method1();
13. task.method2();
15. //确保两个异步调用执行完成
16. Thread.sleep(6000);
18. log.info("main线程结束");
19. }
21. }

输出如下：

可以看得出，SpringBoot创建了一个名为applicationTaskExecutor的线程池，使用这里面的线程来执行异步调用。

这里值得注意的是，不要在一个类中调用@Async标注的方法，否则不会起到异步调用的作用，至于为什么会产生这样的问题，需要深入到源码中一探究竟，会另开篇幅。

既然默认使用的是SpringBoot自己创建的applicationTaskExecutor，那如何自己去定义一个线程池呢?

自定义线程池

我们需要手动创建一个名为asynTaskExecutord的Bean

1. packagecom.yang.async;
3. importlombok.extern.slf4j.Slf4j;
4. importorg.springframework.context.annotation.Bean;
5. importorg.springframework.context.annotation.Configuration;
6. importorg.springframework.core.task.AsyncTaskExecutor;
7. importorg.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
9. importjava.util.concurrent.ThreadPoolExecutor;
11. /**
12. *@authorqcy
13. *@create2020/09/0915:31:07
14. */
15. @Slf4j
16. @Configuration
17. publicclassAsyncConfig{
19. @Bean
20. publicAsyncTaskExecutorasyncTaskExecutor(){
21. ThreadPoolTaskExecutorexecutor=newThreadPoolTaskExecutor();
22. executor.setCorePoolSize(8);
23. executor.setMaxPoolSize(16);
24. executor.setQueueCapacity(50);
25. executor.setAllowCoreThreadTimeOut(true);
26. executor.setKeepAliveSeconds(10);
27. executor.setRejectedExecutionHandler(newThreadPoolExecutor.CallerRunsPolicy());
28. executor.setThreadNamePrefix("async-thread-pool-thread");
29. returnexecutor;
30. }
31. }

对以上参数不了解的同学，可以参考我的这篇文章说说线程池

其他类不需要变动，直接运行刚才的testAsyncWithVoidReturn()方法，输出：

看得出来，现在是我们自定义的线程池

如果关心异步调用的返回值，又怎么处理?

获取异步调用的返回结果

获取异步调用的结果，需要利用Future机制，可以参考我的另外一篇文章谈谈Runnable、Future、Callable、FutureTask之间的关系

为Task类增加以下两个方法：

1. @Async
2. publicFuture<String>method3(){
3. log.info("method3开始,执行线程为"+Thread.currentThread().getName());
4. try{
5. Thread.sleep(1000);
6. }catch(InterruptedExceptione){
7. e.printStackTrace();
8. }
9. log.info("method3结束");
10. returnnewAsyncResult<>("method3");
11. }
13. @Async
14. publicFuture<String>method4(){
15. log.info("method4开始,执行线程为"+Thread.currentThread().getName());
16. try{
17. Thread.sleep(3000);
18. }catch(InterruptedExceptione){
19. e.printStackTrace();
20. }
21. log.info("method4结束");
22. returnnewAsyncResult<>("method4");
23. }

测试类：

1. @Test
2. publicvoidtestAsyncWithStringReturn()throwsInterruptedException,ExecutionException{
3. log.info("main线程开始");
5. Future<String>method3Result=task.method3();
6. Future<String>method4Result=task.method4();
8. //get方法为阻塞获取
9. log.info("method3执行的返回结果:{}",method3Result.get());
10. log.info("method4执行的返回结果:{}",method4Result.get());
11. log.info("main线程结束");
12. }

输出：

如图，在主线程结束前，获取到了异步调用的结果。且在两个异步调用都结束的情况下，继续执行主线程。

原文地址：https://www.toutiao.com/i6944877804123079207/