经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Spring Boot » 查看文章
SpringBoot使用@Async的总结！
来源：cnblogs　　作者：雨点的名字　　时间：2022/11/21 9:02:55　　对本文有异议

一些业务场景我们需要使用多线程异步执行任务，加快任务执行速度。

之前有写过一篇文章叫做: 异步编程利器：CompletableFuture

在实际工作中也更加推荐使用CompletableFuture，因为它实现异步方式更加优雅，而且功能更加强大！

既然SpringBoot能通过 @Async 也实现异步执行任务，那么这篇文章就来总结下如何使用 @Async 实现异步执行任务。

一、SpringBoot使用@Async注解步骤

1、启动类上使用@EnableAsync注解

  1. @SpringBootApplication
  2. @EnableAsync
  3. public class Application {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(Application.class, args);
  7.     }
  8. }

2、异步方法所在的类注入容器中

  1.  @Componet
  2.  public class Test{
  4. }

除了@Componet，也可以是@Controller、@RestController、@Service、@Configuration等注解，加入到Ioc容器里。

3、方法上加上@Async注解

  1. @Service
  2.  public class Test{
  4. 	@Async
  5. 	public void a() {
  7. 	}
  8. }

二、哪些情况会导致@Async异步失效？

如果你明明是按照上面的步骤来的，但是发现@Async注解还是不起作用，这里还有两点注意，因为@Async是基于Aop思想实现的,所有下面两种情况也会失效。

1、异步方法使用static修饰

  1.     @Async
  2.     public static void a() {
  4.     }

2、调用方法和异步方法在同一个类中

当异步方法和调用方法在同一个类中时，是没办法通过Ioc里的bean来执行异步方法的，从而变成同步方法。

如下：

  1. @Component
  2. public class Task {
  4.     /**
  5.      * 调异步方法和异步方法在同一个类 @Async执行失败
  6.      */
  7.     public void dotask() {
  8.         this.taskOne();
  9.         this.taskTwo();
  10.     }
  12.     @Async
  13.     public void taskOne() {
  14.         //执行任务1
  15.     }
  16.     
  17.     @Async
  18.     public void taskTwo() {
  19.         //执行任务2
  20.     }
  21. }

三、SpringBoot结合@Async实现异步示例

首先我们来看同步方法

1、同步调用示例

  1. @Component
  2. @Slf4j
  3. public class DemoTask {
  4.     
  5.     public void taskOne() throws Exception {
  6.         log.info("===执行任务1===");
  7.         long start = System.currentTimeMillis();
  8.         Thread.sleep(200);
  9.         long end = System.currentTimeMillis();
  10.         log.info("任务1执行结束,总耗时={} 毫秒", end - start);
  11.     }
  13.     public void taskTwo() throws Exception {
  14.         log.info("===执行任务2===");
  15.         long start = System.currentTimeMillis();
  16.         Thread.sleep(200);
  17.         long end = System.currentTimeMillis();
  18.         log.info("任务2执行结束,总耗时={} 毫秒", end - start);
  19.     }
  21.     public void taskThere() throws Exception {
  22.         log.info("===执行任务3===");
  23.         long start = System.currentTimeMillis();
  24.         Thread.sleep(200);
  25.         long end = System.currentTimeMillis();
  26.         log.info("任务3执行结束,总耗时={} 毫秒", end - start);
  27.     }
  28. }

执行方法

  1. @Slf4j
  2. @RunWith(SpringRunner.class)
  3. @SpringBootTest
  4. public class DemoTaskTest {
  6.     @Autowired
  7.     private DemoTask demoTask;
  8.     
  9.     @Test
  10.     public void runDemo() throws Exception {
  11.         long start = System.currentTimeMillis();
  12.         demoTask.taskOne();
  13.         demoTask.taskTwo();
  14.         demoTask.taskThere();
  15.         long end = System.currentTimeMillis();
  16.         log.info("总任务执行结束,总耗时={} 毫秒", end - start);
  17.     }
  18. }

输出日志

  1. ===执行任务1===
  2. 任务1执行结束,总耗时=204 毫秒
  3. ===执行任务2===
  4. 任务2执行结束,总耗时=203 毫秒
  5. ===执行任务3===
  6. 任务3执行结束,总耗时=201 毫秒
  7. 总任务执行结束,总耗时=613 毫秒

2、异步调用示例

异步方法

  1. @Component
  2. @Slf4j
  3. public class AsyncTask {
  5.     @Async
  6.     public void taskOne() throws Exception {
  7.       //执行内容同上，省略
  8.     }
  10.     @Async
  11.     public void taskTwo() throws Exception {
  12.       //执行内容同上，省略
  13.     }
  15.     @Async
  16.     public void taskThere() throws Exception {
  17.        //执行内容同上，省略
  18.     }
  19. }

调用方法

  1. @Slf4j
  2. @RunWith(SpringJUnit4ClassRunner.class)
  3. @EnableAsync
  4. @SpringBootTest
  5. public class AsyncTest {
  7.     @Autowired
  8.     private AsyncTask asyncTask;
  10.     @Test
  11.     public void runAsync() throws Exception {
  12.         long start = System.currentTimeMillis();
  13.         asyncTask.taskOne();
  14.         asyncTask.taskTwo();
  15.         asyncTask.taskThere();
  16.         Thread.sleep(200);
  17.         long end = System.currentTimeMillis();
  18.         log.info("总任务执行结束,总耗时={} 毫秒", end - start);
  19.     }
  20. }

查看日志

  1. ===执行任务1===
  2. ===执行任务3===
  3. ===执行任务2===
  4. 总任务执行结束,总耗时=206 毫秒
  5. 任务1执行结束,总耗时=200 毫秒
  6. 任务2执行结束,总耗时=201 毫秒
  7. 任务3执行结束,总耗时=201 毫秒

通过日志可以看出已经是已经实现异步处理任务了,而且异步任务哪个先执行是不确定的。

3、Future异步回调

如果我想异步执行，同时想获取所有异步执行的结果，那么这个时候就需要采用Future。

异步方法

  1. @Component
  2. @Slf4j
  3. public class FutureTask {
  4.     
  5.     @Async
  6.     public Future<String> taskOne() throws Exception {
  7.         //执行内容同上，省略
  8.         return new AsyncResult<>("1完成");
  9.     }
  10.     @Async
  11.     public Future<String> taskTwo() throws Exception {
  12.         //执行内容同上，省略
  13.         return new AsyncResult<>("2完成");
  14.     }
  16.     @Async
  17.     public Future<String> taskThere() throws Exception {
  18.         //执行内容同上，省略
  19.         return new AsyncResult<>("执行任务3完成");
  20.     }
  21. }

调用方法

  1. @Slf4j
  2. @RunWith(SpringRunner.class)
  3. @SpringBootTest
  4. @EnableAsync
  5. public class FutureTaskTest {
  7.     @Autowired
  8.     private FutureTask futureTask;
  10.     @Test
  11.     public void runAsync() throws Exception {
  12.         long start = System.currentTimeMillis();
  13.         Future<String> taskOne = futureTask.taskOne();
  14.         Future<String> taskTwo = futureTask.taskTwo();
  15.         Future<String> taskThere = futureTask.taskThere();
  17.         while (true) {
  18.             if (taskOne.isDone() && taskTwo.isDone() && taskThere.isDone()) {
  19.                 log.info("任务1返回结果={},任务2返回结果={},任务3返回结果={},", taskOne.get(), taskTwo.get(), taskThere.get());
  20.                 break;
  21.             }
  22.         }
  23.         long end = System.currentTimeMillis();
  24.         log.info("总任务执行结束,总耗时={} 毫秒", end - start);
  25.     }
  26. }

查看日志

  1. ===执行任务2===
  2. ===执行任务3===
  3. ===执行任务1===
  4. 任务1执行结束,总耗时=201 毫秒
  5. 任务3执行结束,总耗时=201 毫秒
  6. 任务2执行结束,总耗时=201 毫秒
  7. 任务1返回结果=1完成,任务2返回结果=2完成,任务3返回结果=执行任务3完成,
  8. 总任务执行结束,总耗时=223 毫秒

从日志可以看出 异步任务的执行结果都有获取。


四、@Async+自定义线程池实现异步任务

如果不自定义异步方法的线程池默认使用SimpleAsyncTaskExecutor线程池。

SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。并发大的时候会产生严重的性能问题。

Spring也更加推荐我们开发者使用ThreadPoolTaskExecutor类来创建线程池。

自定义线程池

  1. @Configuration
  2. public class ExecutorAsyncConfig {
  3.     
  4.     @Bean(name = "newAsyncExecutor")
  5.     public Executor newAsync() {
  6.         ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
  7.         //设置核心线程数
  8.         taskExecutor.setCorePoolSize(10);
  9.         // 线程池维护线程的最大数量，只有在缓冲队列满了以后才会申请超过核心线程数的线程
  10.         taskExecutor.setMaxPoolSize(100);
  11.         //缓存队列
  12.         taskExecutor.setQueueCapacity(50);
  13.         //允许的空闲时间，当超过了核心线程数之外的线程在空闲时间到达之后会被销毁
  14.         taskExecutor.setKeepAliveSeconds(200);
  15.         //异步方法内部线程名称
  16.         taskExecutor.setThreadNamePrefix("my-xiaoxiao-AsyncExecutor-");
  17.         //拒绝策略
  18.         taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
  19.         taskExecutor.initialize();
  20.         return taskExecutor;
  21.     }
  22. }

示例代码

任务1和任务2配置走我们自定义的线程池，任务3还是走默认线程池。

  1. @Component
  2. @Slf4j
  3. public class FutureExecutorTask {
  5.     @Async("newAsyncExecutor")
  6.     public Future<String> taskOne() throws Exception {
  7.         log.info("任务1线程名称 = {}", Thread.currentThread().getName());
  8.         return new AsyncResult<>("1完成");
  9.     }
  10.     @Async("newAsyncExecutor")
  11.     public Future<String> taskTwo() throws Exception {
  12.         log.info("任务2线程名称 = {}", Thread.currentThread().getName());
  13.         return new AsyncResult<>("2完成");
  14.     }
  16.     @Async
  17.     public Future<String> taskThere() throws Exception {
  18.         log.info("任务3线程名称 = {}", Thread.currentThread().getName());
  19.         return new AsyncResult<>("执行任务3完成");
  20.     }
  21. }

调研方法和上面一样，我们再来看下日志

  1. 任务2线程名称 = my-xiaoxiao-AsyncExecutor-2
  2. 任务1线程名称 = my-xiaoxiao-AsyncExecutor-1
  3. 任务3线程名称 = SimpleAsyncTaskExecutor-1
  4. 总任务执行结束,总耗时=15 毫秒

通过日志我们可以看出 任务1和任务2走的是我们自定义的线程池，任务3还是走默认线程池。


五、CompletableFuture实现异步任务

推荐这种方式来实现异步,它不需要在启动类上加@EnableAsync注解，也不需要在方法上加@Async注解,它实现更加优雅，而且CompletableFuture功能更加强大。

具体可以看下之前写的文章:异步编程利器：CompletableFuture

1、CompletableFuture示例

看如何使用

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @SpringBootTest
  3. public class CompletableTest {
  5.     @Autowired
  6.     private DemoTask dmoTask;
  7.     
  8.     @Test
  9.     public void testCompletableThenRunAsync() throws Exception {
  10.         long startTime = System.currentTimeMillis();
  12.         CompletableFuture<Void> cp1 = CompletableFuture.runAsync(() -> {
  13.             //任务1
  14.             dmoTask.taskOne();
  15.         });
  16.         CompletableFuture<Void> cp2 = CompletableFuture.runAsync(() -> {
  17.             //任务2
  18.             dmoTask.taskTwo();
  19.         });
  20.         CompletableFuture<Void> cp3 = CompletableFuture.runAsync(() -> {
  21.             //任务3
  22.             dmoTask.taskThere();
  23.         });
  24.         
  25.         cp1.get();
  26.         cp2.get();
  27.         cp3.get();
  28.         //模拟主程序耗时时间
  29.         System.out.println("总共用时" + (System.currentTimeMillis() - startTime) + "ms");
  30.     }
  31. }

查看日志

  1. ===执行任务1===
  2. ===执行任务2===
  3. ===执行任务3===
  4. 任务3执行结束,总耗时=204 毫秒
  5. 任务2执行结束,总耗时=203 毫秒
  6. 任务1执行结束,总耗时=204 毫秒
  7. 总共用时226ms

从日志可以看出，通过CompletableFuture同样可以实现异步执行任务！



声明: 公众号如需转载该篇文章,发表文章的头部一定要 告知是转至公众号: 后端元宇宙。同时也可以问本人要markdown原稿和原图片。其它情况一律禁止转载！

原文链接：https://www.cnblogs.com/qdhxhz/p/16671089.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Spring Boot热门文章

  • 史上最详 Thymeleaf 使用教程
  • Spring Boot如何通过java -jar启动
  • Spring Boot 2.x（六）：优雅的统一返回值
  • Springboot使用Logback实现日志配置与异常记录
  • 使用SpringBoot+EasyExcel+Vue实现excel表格的导入和导出详解
  • spring boot上传文件超出大小异常无法捕获问题
  • paging组件的用法和意义
  • springboot2.0集成rabbitmq的示例代码
  • Spring MVC学习step1——框架熟悉
  • spring boot ${}占位符不起作用的解决方案

    • Spring Boot推荐文章

  • 3分钟带你搞定Spring Boot中Schedule
  • 不单独部署注册中心，又要具备注册中心的功能，我能上天！
  • 从零开始学Spring Boot系列-集成Spring Security实现用户认证与授权
  • 不单独部署注册中心，又要具备注册中心的功能，咋不让我上天？
  • EasyExcel 无法读取图片？用poi写了一个工具类
  • 【进阶篇】使用 Stream 流对比两个集合的常用操作分享
  • 关于DDD和COLA的一些总结和思考
  • SnakeYaml反序列化分析
  • RestTemplate进行https请求时适配信任证书
  • Kryo反序列化链分析

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号