Spring系列之@EnableAsync & @Async 实现方法异步调用

1、本文内容

详解 @EnableAsync & @Async,主要分下面几个点进行介绍。

  1. 作用
  2. 用法
  3. 获取异步执行结果
  4. 自定义异步执行的线程源码中的图片
  5. 自定义approach异常处理
  6. 线程隔离
  7. 源码 & 原理

2、作用

spring容器中实现bean方法的异步调用。

比如有个logServiceappear的bean,logservice中有个log方法用来记录日志,当调用logService.log(msg)的时候,希望异步执行,那么可以通过@EnableAsync & @Async来实现。

3、用法

2步

  1. 需要异步执行的方法上面使用@Async注解标注,若bean中所有的方法都需要异步执行,可以直接将@Asy异常处理机制nc加载类上。
  2. @EnableAsync添加在spring配置类上,此时@Asyncappear注解才会起效。

常见2种用法

  1. 无返回值的
  2. 可以获取返回值的

4、无返回值的

用法

方法效率计算公式返回值不是Futur接口和抽象类的区别e类型的,被执行时,会立即返回,并且无法获取方法返回值,如:

@Async
publicvoidlog(Stringmsg)throwsInterruptedException{
System.out.println("开始记录日志,"+System.currentTimeMillis());
//模拟耗时2秒
TimeUnit.SECONDS.sleep(2);
System.out.println("日志记录完毕,"+System.currentTimeMillis());
}

案例

实现日志异步记录的功能。

LogService.log方法用来异步记录日志,需要使用@Async标注

packagecom.javacode2018.async.demo1;
importorg.springframework.scheduling.annotation.Async;
importorg.springframework.stereotype.Component;
importjava.util.concurrent.TimeUnit;
@Component
publicclassLogService{
@Async
publicvoidlog(Stringmsg)throwsInterruptedException{
System.out.println(Thread.currentThread()+"开始记录日志,"+System.currentTimeMillis());
//模拟耗时2秒
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread()+"日志记录完毕,"+System.currentTimeMillis());
}
}

来个spring配置类,需要加上@EnableAsync开启bean方法的异步调用.

packagecom.javacode2018.async.demo1;
importorg.springframework.context.annotation.ComponentScan;
importorg.springframework.context.annotation.EnableAspectJAutoProxy;
importorg.springframework.scheduling.annotation.EnableAsync;
@ComponentScan
@EnableAsync
publicclassMainConfig1{
}

测试代码

packagecom.javacode2018.async;
importcom.javacode2018.async.demo1.LogService;
importcom.javacode2018.async.demo1.MainConfig1;
importorg.junit.Test;
importorg.springframework.context.annotation.AnnotationConfigApplicationContext;
importjava.util.concurrent.TimeUnit;
publicclassAsyncTest{
@Test
publicvoidtest1()throwsInterruptedException{
AnnotationConfigApplicationContextcontext=newAnnotationConfigApplicationContext();
context.register(MainConfig1.class);
context.refresh();
LogServicelogService=context.getBean(LogService.class);
System.out.println(Thread.currentThread()+"logService.logstart,"+System.currentTimeMillis());
logService.log("异步执行方法!");
System.out.println(Thread.currentThread()+"logService.logend,"+System.currentTimeMillis());
//休眠一下,防止@Test退出
TimeUnit.SECONDS.sleep(3);
}
}

运行输出

Thread[main,5,main]logService.logstart,1595223990417
Thread[main,5,main]logService.logend,1595223990432
Thread[SimpleAsyncTaskExecutor-1,5,main]开始记录日志,1595223990443
Thread[SimpleAsyncTaskExecutor-1,5,main]日志记录完毕,1595223992443

前2行输出,可以看出logService.log立即就返回源码网站了,后面2行来自于log方法,相差2秒左右。

前面2行在主线程中执行,后面2行在异步线程中执行。

5、获取异步返回生产异常处理

用法

若需取异步执行结果,方法返回值必须为Future类型,使用spring提供的静态方法org.springframework.scheduling.annotati接口和抽象类的区别o异常处理流程n.AsappleyncResult#forVa接口自动化lue创建返回值,如:

publicFuture<String>getGoodsInfo(longgoodsId)throwsInterruptedException{
returnAsyncResult.forValue(String.format("商品%s基本信息!",goodsId));
}

案例

场景:电商中商品详情页通常接口自动化会有很多信息:商品基本信息、商品描述信息、商品评论信息,通过3个方法来或者这几个信息。

这3个方法之间无关联,所以可以采用异步的方式并行获取,提升效率

下面是商品服务,内部3个方法都需要异步,所以直接在类上使用@Async标注了,每个方法内部休眠500毫秒,模application拟一下耗时操作。

packagecom.javacode2018.async.demo2;
importorg.springframework.scheduling.annotation.Async;
importorg.springframework.scheduling.annotation.AsyncResult;
importorg.springframework.stereotype.Component;
importjava.util.Arrays;
importjava.util.List;
importjava.util.concurrent.Future;
importjava.util.concurrent.TimeUnit;
@Async
@Component
publicclassGoodsService{
//模拟获取商品基本信息,内部耗时500毫秒
publicFuture<String>getGoodsInfo(longgoodsId)throwsInterruptedException{
TimeUnit.MILLISECONDS.sleep(500);
returnAsyncResult.forValue(String.format("商品%s基本信息!",goodsId));
}
//模拟获取商品描述信息,内部耗时500毫秒
publicFuture<String>getGoodsDesc(longgoodsId)throwsInterruptedException{
TimeUnit.MILLISECONDS.sleep(500);
returnAsyncResult.forValue(String.format("商品%s描述信息!",goodsId));
}
//模拟获取商品评论信息列表,内部耗时500毫秒
publicFuture<List<String>>getGoodsComments(longgoodsId)throwsInterruptedException{
TimeUnit.MILLISECONDS.sleep(500);
List<String>comments=Arrays.asList("评论1","评论2");
returnAsyncResult.forValue(comments);
}
}

来个spring配置类,需要加上@EnableAsync接口和抽象类的区别开启bean方法的异步调用.

packagecom.javacode2018.async.demo2;
importorg.springframework.context.annotation.ComponentScan;
importorg.springframework.scheduling.annotation.EnableAsync;
@ComponentScan
@EnableAsync
publicclassMainConfig2{
}

测试代码

@Test
publicvoidtest2()throwsInterruptedException,ExecutionException{
AnnotationConfigApplicationContextcontext=newAnnotationConfigApplicationContext();
context.register(MainConfig2.class);
context.refresh();
GoodsServicegoodsService=context.getBean(GoodsService.class);
longstarTime=System.currentTimeMillis();
System.out.println("开始获取商品的各种信息");
longgoodsId=1L;
Future<String>goodsInfoFuture=goodsService.getGoodsInfo(goodsId);
Future<String>goodsDescFuture=goodsService.getGoodsDesc(goodsId);
Future<List<String>>goodsCommentsFuture=goodsService.getGoodsComments(goodsId);
System.out.println(goodsInfoFuture.get());
System.out.println(goodsDescFuture.get());
System.out.println(goodsCommentsFuture.get());
System.out.println("商品信息获取完毕,总耗时(ms):"+(System.currentTimeMillis()-starTime));
//休眠一下,防止@Test退出
TimeUnit.SECONDS.sleep(3);
}

运行输出

开始获取商品的各种信息
商品1基本信息!
商品1描述信息!
[评论1,评论2]
商品信息获取完毕,总耗时(ms):525

3个方法总计耗时500毫秒左右。

如果不采用异步的方式,3个方法会同步执行,耗时差源码时代不多1.5秒,来试试,将GoodsService上的@Async去掉,然后再次执行测试案例,输出源码编程器

开始获取商品的各种信息
商品1基本信息!
商品1描述信息!
[评论1,评论2]
商品信息获取完毕,总耗时(ms):1503

这个案例大家可以借鉴一下,按照这个思路可以去优化一下你们的代码,方法之间无关联的可以采用异步的方式,并行去获取,最终耗时为最长的那个方法设备异常处理,整体相对于同步的方式性能提升不少。

6、自定义异步执行的线程池

默认情况下,@EnableAs源码交易平台ync使用内置的线程池来异步调用方法,不过我们也可以自定义异步执行任务的接口测试线程池。

有2种方式来自定义异步处理的线程池

方式1

在spring容器中定义一个线程池类型异常处理的bean,bean名称必须是taskExecutor

@Bean
publicExecutortaskExecutor(){
ThreadPoolTaskExecutorexecutor=newThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(100);
executor.setThreadNamePrefix("my-thread-");
returnexecutor;
}

方式2

定义一个bean,实现AsyncConfigurer接口中的get效率公式AsyncExecutor方法,这个方法需要返回自定义的线程池,案例代码:

packagecom.javacode2018.async.demo3;
importcom.javacode2018.async.demo1.LogService;
importorg.springframework.beans.factory.annotation.Qualifier;
importorg.springframework.context.annotation.Bean;
importorg.springframework.lang.Nullable;
importorg.springframework.scheduling.annotation.AsyncConfigurer;
importorg.springframework.scheduling.annotation.EnableAsync;
importorg.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
importjava.util.concurrent.Executor;
@EnableAsync
publicclassMainConfig3{
@Bean
publicLogServicelogService(){
returnnewLogService();
}
/**
*定义一个AsyncConfigurer类型的bean,实现getAsyncExecutor方法,返回自定义的线程池
*
*@paramexecutor
*@return
*/
@Bean
publicAsyncConfigurerasyncConfigurer(@Qualifier("logExecutors")Executorexecutor){
returnnewAsyncConfigurer(){
@Nullable
@Override
publicExecutorgetAsyncExecutor(){
returnexecutor;
}
};
}
/**
*定义一个线程池,用来异步处理日志方法调用
*
*@return
*/
@Bean
publicExecutorlogExecutors(){
ThreadPoolTaskExecutorexecutor=newThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(100);
//线程名称前缀
executor.setThreadNamePrefix("log-thread-");//@1
returnexecutor;
}
}

@1自定义的线程池中线程名称前缀为log-thread-,运行下面测试代源码精灵永久兑换码

@Test
publicvoidtest3()throwsInterruptedException{
AnnotationConfigApplicationContextcontext=newAnnotationConfigApplicationContext();
context.register(MainConfig3.class);
context.refresh();
LogServicelogService=context.getBean(LogService.class);
System.out.println(Thread.currentThread()+"logService.logstart,"+System.currentTimeMillis());
logService.log("异步执行方法!");
System.out.println(Thread.currentThread()+"logService.logend,"+System.currentTimeMillis());
//休眠一下,防止@Test退出
TimeUnit.SECONDS.sleep(3);
}

输出

Thread[main,5,main]logService.logstart,1595228732914
Thread[main,5,main]logService.logend,1595228732921
Thread[log-thread-1,5,main]开始记录日志,1595228732930
Thread[log-thread-1,5,main]日志记录完毕,1595228734931

最后2行日志中线程名称是log-thread-,正是我们自定义线程池中的线程。

7、自定义异常处理

异步方法若发生了异常,我们如何获效率的英文取异常信息呢?此时可以通过自定源码精灵永久兑换码义异常处理来解决。

异常处理分2种情况

  1. 当返回值是Future的时候,方法内异常处理员是干什么的部有异常的时候,异常会向外抛出,可以对Future.get采用try..catch来捕获appetite异常
  2. 当返回值不是Future的时候,可以自定义一个bean,实现AsyncConfigurer接口中的getAsyncUncaughtExceptionHandler方法,appstore返回自定义的异常处理器

情况1:返回值为Future类型

用法

通过try..catch来捕获异常,如下

try{
Future<String>future=logService.mockException();
System.out.println(future.get());
}catch(ExecutionExceptione){
System.out.println("捕获ExecutionException异常");
//通过e.getCause获取实际的异常信息
e.getCause().printStackTrace();
}catch(InterruptedExceptione){
e.printStackTrace();
}

案例

LogService中添加一个方法,返回值为Future,内部抛出一个异常,如下:

@Async
publicFuture<String>mockException(){
//模拟抛出一个异常
thrownewIllegalArgumentException("参数有误!");
}

测试代码如下

@Test
publicvoidtest5()throwsInterruptedException{
AnnotationConfigApplicationContextcontext=newAnnotationConfigApplicationContext();
context.register(MainConfig1.class);
context.refresh();
LogServicelogService=context.getBean(LogService.class);
try{
Future<String>future=logService.mockException();
System.out.println(future.get());
}catch(ExecutionExceptione){
System.out.println("捕获ExecutionException异常");
//通过e.getCause获取实际的异常信息
e.getCause().printStackTrace();
}catch(InterruptedExceptione){
e.printStackTrace();
}
//休眠一下,防止@Test退出
TimeUnit.SECONDS.sleep(3);
}

运行输出

java.lang.IllegalArgumentException:参数有误!
捕获ExecutionException异常
atcom.javacode2018.async.demo1.LogService.mockException(LogService.java:23)
atcom.javacode2018.async.demo1.LogService$$FastClassBySpringCGLIB$$32a28430.invoke(<generated>)
atorg.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)

情况2:无返回值异常处理

用法appear

当返回值不是Future的时候,可以自定义一个bean,实现AsyncC设备异常处理onfigurer源码1688接口中的getAsyncUncaughtExceptionHandler方法,返回自定义的异常处理器异常处理机制,当目标方法执行过程中抛出源码精灵永久兑换码异常的时候,此时会自动设备异常处理设备异常处理A效率英文翻译syncUncaughtExceptionHandapproachler#handleUnc源码编辑器aughtException这个方法,可以在这个方法中处理异常,如下:

@Bean
publicAsyncConfigurerasyncConfigurer(){
returnnewAsyncConfigurer(){
@Nullable
@Override
publicAsyncUncaughtExceptionHandlergetAsyncUncaughtExceptionHandler(){
returnnewAsyncUncaughtExceptionHandler(){
@Override
publicvoidhandleUncaughtException(Throwableex,Methodmethod,Object...params){
//当目标方法执行过程中抛出异常的时候,此时会自动回调这个方法,可以在这个方法中处理异常
}
};
}
};
}

效率符号

LogService中添效率的拼音加一个方法,内部抛出一个异常,如下:

@Async
publicvoidmockNoReturnException(){
//模拟抛出一个异常
thrownewIllegalArgumentException("无返回值的异常!");
}

来个spring配置类,通过AsyncConfigurer来自定义异常处理器AsyncUncaughtEappointmentxceptionHandler

packagecom.javacode2018.async.demo4;
importcom.javacode2018.async.demo1.LogService;
importorg.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
importorg.springframework.context.annotation.Bean;
importorg.springframework.lang.Nullable;
importorg.springframework.scheduling.annotation.AsyncConfigurer;
importorg.springframework.scheduling.annotation.EnableAsync;
importjava.lang.reflect.Method;
importjava.util.Arrays;
@EnableAsync
publicclassMainConfig4{
@Bean
publicLogServicelogService(){
returnnewLogService();
}
@Bean
publicAsyncConfigurerasyncConfigurer(){
returnnewAsyncConfigurer(){
@Nullable
@Override
publicAsyncUncaughtExceptionHandlergetAsyncUncaughtExceptionHandler(){
returnnewAsyncUncaughtExceptionHandler(){
@Override
publicvoidhandleUncaughtException(Throwableex,Methodmethod,Object...params){
Stringmsg=String.format("方法[%s],参数[%s],发送异常了,异常详细信息:",method,Arrays.asList(params));
System.out.println(msg);
ex.printStackTrace();
}
};
}
};
}
}

运行输出

方法[publicvoidcom.javacode2018.async.demo1.LogService.mockNoReturnException()],参数[[]],发送异常了,异常详细信息:
java.lang.IllegalArgumentException:无返回值的异常!
atcom.javacode2018.async.demo1.LogService.mockNoReturnException(LogService.java:29)
atcom.javacode2018.async.demo1.LogService$$FastClassBySpringCGLIB$$32a28430.invoke(<generated>)
atorg.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)

8、线程池隔离

什么是application线程池隔离?

一个系统中可能有很多业务,比如充值服务、提现服务或者其他服务,这些服务中都有一些方法需要异步执行,默认情况下他们会使用同一个线程池去执行,如果有一个业务量比较大,效率符号占用源码编程器了线程池中的大量线程,此时会导致其他业务的方法无法执行,那么我们可以效率英文翻译采用线程隔离的方式,对不同的业务使用不同的线程池,相互隔离,互不appstore影响。

@Asappointmentync注解有个value参数,用来指定线程池的bean名称,方法运行的时候,就会采用指定的线程池来执行目标方法。

使用步骤

  1. 在spring容器中,自定义线程池相关的beaappointmentn
  2. @Async(“线程池bean名称”)

案例

模拟2个业务:异步接口测试充值、异步提现;2个业务都采用独立的线程池来异步执行,互不影响。

异步充值服务
packagecom.javacode2018.async.demo5;
importorg.springframework.scheduling.annotation.Async;
importorg.springframework.stereotype.Component;
@Component
publicclassRechargeService{
//模拟异步充值
@Async(MainConfig5.RECHARGE_EXECUTORS_BEAN_NAME)
publicvoidrecharge(){
System.out.println(Thread.currentThread()+"模拟异步充值");
}
}
异步提现服务
packagecom.javacode2018.async.demo5;
importorg.springframework.scheduling.annotation.Async;
importorg.springframework.stereotype.Component;
@Component
publicclassCashOutService{
//模拟异步提现
@Async(MainConfig5.CASHOUT_EXECUTORS_BEAN_NAME)
publicvoidcashOut(){
System.out.println(Thread.currentThread()+"模拟异步提现");
}
}
spring配置类

注意@0、@1、@2、@3、@4这几个地方的代接口和抽象类的区别码,采用线程池隔离的接口测试用例设计方式,注册了2个线程池,分别用来处理上面的2个异步业务。

packagecom.javacode2018.async.demo5;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.ComponentScan;
importorg.springframework.scheduling.annotation.EnableAsync;
importorg.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
importjava.util.concurrent.Executor;
@EnableAsync//@0:启用方法异步调用
@ComponentScan
publicclassMainConfig5{
//@1:值业务线程池bean名称
publicstaticfinalStringRECHARGE_EXECUTORS_BEAN_NAME="rechargeExecutors";
//@2:提现业务线程池bean名称
publicstaticfinalStringCASHOUT_EXECUTORS_BEAN_NAME="cashOutExecutors";
/**
*@3:充值的线程池,线程名称以recharge-thread-开头
*@return
*/
@Bean(RECHARGE_EXECUTORS_BEAN_NAME)
publicExecutorrechargeExecutors(){
ThreadPoolTaskExecutorexecutor=newThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(100);
//线程名称前缀
executor.setThreadNamePrefix("recharge-thread-");
returnexecutor;
}
/**
*@4:充值的线程池,线程名称以cashOut-thread-开头
*
*@return
*/
@Bean(CASHOUT_EXECUTORS_BEAN_NAME)
publicExecutorcashOutExecutors(){
ThreadPoolTaskExecutorexecutor=newThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(100);
//线程名称前缀
executor.setThreadNamePrefix("cashOut-thread-");
returnexecutor;
}
}
测试代码
@Test
publicvoidtest7()throwsInterruptedException{
AnnotationConfigApplicationContextcontext=newAnnotationConfigApplicationContext();
context.register(MainConfig5.class);
context.refresh();
RechargeServicerechargeService=context.getBean(RechargeService.class);
rechargeService.recharge();
CashOutServicecashOutService=context.getBean(CashOutService.class);
cashOutService.cashOut();
//休眠一下,防止@Test退出
TimeUnit.SECONDS.sleep(3);
}
运行输出
Thread[recharge-thread-1,5,main]模拟异步充值
Thread[cashOut-thread-1,5,main]模拟异步提现

接口测试出中可以看出2个业务使用的是不同的效率计算公式线程池执行的。

9、源码 & 原理

内部使用aop实现的,@E异常处理流程nableAsync会引入一个bean后置处理器:As效率公式yncAnnotation源码1688BeanPostProcess源码交易平台or,将其注册到spring容器,这个bean后置处理器在所有bean创建过程中,判断bean的类上是否有@Async注解或设备异常处理者类中是否有@Async标注的方法,如果有,会通过aop给这个bean生成代理对象,会在代理对象中添加一个切面:org.spr接口测试ingframework.scheduling.annotation.AsyncAnnotationAdvisor,这个切面中会引入一个拦截器:AnnotationAsyncExecutionInterceptor,方法异步调用的关键代码就是在这个拦截器的invoke方法中实现的,可以去看一下。

发表评论

提供最优质的资源集合

立即查看 了解详情