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

1、本文内容

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

作用
用法
获取异步执行结果
自定义异步执行的线程源码中的图片池
自定义approach异常处理
线程隔离
源码 & 原理

2、作用

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

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

3、用法

2步

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

常见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种情况

当返回值是Future的时候，方法内异常处理员是干什么的部有异常的时候，异常会向外抛出，可以对Future.get采用try..catch来捕获appetite异常
当返回值不是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名称，方法运行的时候，就会采用指定的线程池来执行目标方法。

使用步骤

在spring容器中，自定义线程池相关的beaappointmentn
@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方法中实现的，可以去看一下。

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

1、本文内容

2、作用

3、用法

2步

常见2种用法

4、无返回值的

用法

案例

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

用法

案例

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

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

方式1

方式2

7、自定义异常处理

异常处理分2种情况

情况1：返回值为Future类型

用法

案例

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

用法appear

案效率符号例

8、线程池隔离

什么是application线程池隔离？

使用步骤

案例

异步充值服务

异步提现服务

spring配置类

测试代码

运行输出

9、源码 & 原理

相关文章

🦖不是DINOSAUR是DINOISER：通过噪声表影响条件序列扩散模型效果

编排式规则引擎LiteFlow在转转轻质检报告的实践

老司机带你看Java 编程问题——文本块、区域设置、数字和数学

隔离期间搭建一个自己的个人博客

作者信息