springboot:异步注解@Async的前世今生

在前边的文章中,和小伙伴一起认识了异步执行的好处,以及如何进行异步开发,对,就是使用@Async注解,在使用异步注解@Async的过程中也存在一些坑,不过通过正确的打开方式也可以很好的避免,今天想和大家分享下@Async的原理,开始前先温习下之前的文章哦,

 

一、引言

在前边说到在使用@Async的时候,在一个类中两个@Async的方法嵌套使用会导致异步失败,下面把场景重现下,

AsyncContoller.java

package com.example.myDemo.controller;  import com.example.myDemo.service.AsyncService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.ResponseBody; import java.util.concurrent.ExecutionException;  @Controller public class AsyncController {     @Autowired     private AsyncService asyncService;     @GetMapping("/aysnc")     @ResponseBody     public String asyncMethod(){         try {             Long start=System.currentTimeMillis();             //调用method3方法,该方法中嵌套了一个异步方法             String str3=asyncService.method3().get();             Long end=System.currentTimeMillis();             System.out.println("执行时长:"+(end-start));         } catch (ExecutionException | InterruptedException e) {             e.printStackTrace();         }         return "hello @Async";     } }

下面是method3方法

package com.example.myDemo.service;  import org.springframework.scheduling.annotation.Async; import org.springframework.scheduling.annotation.AsyncResult; import org.springframework.stereotype.Service; import java.util.concurrent.Future;  @Service @Async public class AsyncService {     /**      * 第一个异步方法,睡眠10s返回字符串      *      * @return */ public Future<String> method() {         try {             Thread.sleep(10 * 1000);         } catch (InterruptedException e) {             e.printStackTrace();         }         return new AsyncResult("I am method");     }      /**      * 第三个异步方法,在该异步方法中调用了另外一个异步方法      * @return */ public Future<String> method3(){         try{
            //睡眠10s             Thread.sleep(10*1000);             System.out.println(this);
            //method方法也是睡眠10s             this.method();          }catch (InterruptedException e) {             e.printStackTrace();         }         return new AsyncResult<>("two async method");     } }

上面便是method3方法,以及嵌套在method3方法中的method方法,这两个方法体上均没有标注@Async,只是在这个类上使用了@Async注解,那么该类中的所有方法都是异步的。

执行结果如下,

2022-04-30 15:29:47.711  INFO 16836 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 4 ms com.example.myDemo.service.AsyncService@7e316231 执行时长:20028

从上面可以看到整个方法的执行时长是20多秒,那么就说明这种同一个类中的嵌套调用,@Async是失效的

二、解决方式

1、把嵌套方法抽到另一个类中

这种方式就是把嵌套的异步方法method抽取到另外一个类中,下面我们来看下,

OtherService.java

package com.example.myDemo.service;  import org.springframework.scheduling.annotation.Async; import org.springframework.scheduling.annotation.AsyncResult; import org.springframework.stereotype.Service; import java.util.concurrent.Future;  @Service @Async public class OtherAsyncService {     public Future<String> method() {         try {             Thread.sleep(10 * 1000);         } catch (InterruptedException e) {             e.printStackTrace();         }         return new AsyncResult("I am method");     } }

那么AsyncService.java则变成下面的样子

package com.example.myDemo.service;  import org.springframework.beans.factory.annotation.Autowired; import org.springframework.scheduling.annotation.Async; import org.springframework.scheduling.annotation.AsyncResult; import org.springframework.stereotype.Service;  import java.util.concurrent.Future;  @Service @Async public class AsyncService {     //注入OtherService     @Autowired     private OtherAsyncService otherAsyncService;          /**      * 第三个异步方法,在该异步方法中调用了另外一个异步方法      * @return */ public Future<String> method3(){         try{             Thread.sleep(10*1000);             System.out.println(this);            //调用OtherAsyncService的method方法             otherAsyncService.method();          }catch (InterruptedException e) {             e.printStackTrace();         }         return new AsyncResult<>("two async method");     } }

下面看执行的结果,

2022-04-30 15:44:18.914  INFO 16768 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 5 ms com.example.myDemo.service.AsyncService@689927ef 执行时长:10016

执行时长10s多点,符合预期。

2、自己注入自己

这种方式很有意思,我斗胆给它取名为“自己注入自己”,在AsyncService类中注入一个AsyncService的实例,如下

package com.example.myDemo.service;  import org.springframework.beans.factory.annotation.Autowired; import org.springframework.scheduling.annotation.Async; import org.springframework.scheduling.annotation.AsyncResult; import org.springframework.stereotype.Service;  import java.util.concurrent.Future;  @Service @Async public class AsyncService {    //这里注入的是AsyncService的实例
    @Lazy     @Autowired     private AsyncService otherAsyncService;     /**      * 第一个异步方法,睡眠10s返回字符串      *      * @return */ public Future<String> method() {         try {             Thread.sleep(10 * 1000);         } catch (InterruptedException e) {             e.printStackTrace();         }         return new AsyncResult("I am method");     }     /**      * 第三个异步方法,在该异步方法中调用了另外一个异步方法      * @return */ public Future<String> method3(){         try{             Thread.sleep(10*1000);             System.out.println(this);             otherAsyncService.method();          }catch (InterruptedException e) {             e.printStackTrace();         }         return new AsyncResult<>("two async method");     } }

小伙伴们注意,我是在AsyncService类中又注入了一个AsyncService的实例,在method3方法中调用的是AsyncSerevice的方法method,要区别于下面的调用方式

 this.method();

下面看下执行结果,

2022-04-30 15:55:30.635  INFO 9788 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 5 ms com.example.myDemo.service.AsyncService@2ac186f8 执行时长:10015

好了,我们看到执行时长为10s多点,也就是说异步是生效的,在这种方式中要注意注入的对象必须添加@Lazy注解,否则启动会报错哦。

三、原理揭秘

上面已经把嵌套使用的误区和解决方式已经总结完了,下面到了要揭开@Async面纱的时候了,最好的方式是debug,看下面@Async的debug的过程

 

可以看到在AsyncController中asyncService是一个代理对象,且使用的方式是cglib,那么也就是会把其中的方法进行代理,类似下面的代码

before(); method3(); after();

也就是对method3进行了代理,这里的代理指的是把mthod3方法封装成一个task,交给线程池去执行,那么在method3中的this.method()这句调用,也就是普通调用了,是同步的,为什么这样说,因为这里的this代表的是AsyncService这个实例对象,

但是如果换成”自己注入自己的方式”,例如下图,

可以看到还是一个AsyncService的cglib代理对象,所以完美解决了嵌套调用的问题。

四、总结

本文分析了@Async注解的实现原理及如何使用正确使用嵌套调用,

1、@Async注解底层使用的是代理,标记为@Async所在的类在实际调用时是一个代理类;

2、合理使用@Async方法的嵌套,可以把嵌套方法抽到另外一个类中;

3、如果在本类中使用嵌套方法,那么需要自己注入自己,切记加上@Lazy注解;

标签:

商匡云商
Logo
对比商品
  • 合计 (0)
对比
0
购物车