spring boot使用@Async异步注解的实现原理+源码
1、java的大部分接口的方法都是串行执行的，但是有些业务场景是不需要同步返回结果的，可以把结果直接返回，具体业务异步执行，也有些业务接口是需要并行获取数据，最后把数据聚合在统一返回给前端。
通常我们都是采用多线程的方式来实现上述业务功能，但spring 提供更优雅的方式来实现上述功能，就是@Async 异步注解，在方法上添加@Async，spring就会借助AOP，异步执行方法。
1、如何启用@Async
spring boot通过@EnableAsync 注解启用@Async异步注解
实现AsyncConfigurer接口，getAsyncExecutor是默认自定义的线程池
/**
* 线程池配置（@Async）
*/
@Slf4j
@EnableAsync
@Configuration
public class SimpleExecutorConfig implements AsyncConfigurer {
/** 线程池维护线程的最少数量 */
@Value("${executor.corePoolSize}")
private Integer corePoolSize;
/** 线程池维护线程的最大数量 */
@Value("${executor.maxPoolSize}")
private Integer maxPoolSize;
/** 缓冲队列的大小 */
@Value("${executor.queueCapacity}")
private Integer queueCapacity;
/** 为每个线程名设置一个前缀（1） */
@Value("${executor.threadNamePrefix}")
private String threadNamePrefix;
/** 为每个线程名设置一个前缀（2） */
@Value("${executor.threadNamePrefix_2}")
private String threadNamePrefix_2;
@Bean(ExecutorConstant.simpleExecutor_1)
@Override
public Executor getAsyncExecutor() {
//线程池
ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
taskExecutor.setCorePoolSize(corePoolSize);
taskExecutor.setMaxPoolSize(maxPoolSize);
taskExecutor.setQueueCapacity(queueCapacity);
taskExecutor.setThreadNamePrefix(threadNamePrefix);
taskExecutor.initialize();
return taskExecutor;
}
@Bean(ExecutorConstant.simpleExecutor_2)
public Executor asyncExecutor2() {
//线程池
ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
taskExecutor.setCorePoolSize(corePoolSize);
taskExecutor.setMaxPoolSize(maxPoolSize);
taskExecutor.setQueueCapacity(queueCapacity);
taskExecutor.setThreadNamePrefix(threadNamePrefix_2);
taskExecutor.initialize();
return taskExecutor;
}
}
2、如何使用@Async
下面是代码:
TestAsyncService类：
@Slf4j
@Service
public class TestAsyncService implements ITestAsyncService {
/**
* 异步方法，无返回值
* @return
*/
@Async
@Override
public void asyncFunction_1(){
handleBusinessTime();
log.info("asyncFunction_1 当前线程名称是：{}",Thread.currentThread().getName());
};
/////////////////异步方法，无返回值(指定线程池) start
/**
* 异步方法，无返回值(指定线程池)
* @return
*/
@Async(value = ExecutorConstant.simpleExecutor_2)
@Override
public void asyncFunction_2(){
handleBusinessTime();
log.info("asyncFunction_2 当前线程名称是：{}",Thread.currentThread().getName());
};
@Async(ExecutorConstant.simpleExecutor_2)
@Override
public void asyncFunction_3(){
handleBusinessTime();
log.info("asyncFunction_3 当前线程名称是：{}",Thread.currentThread().getName());
};
/////////////////异步方法，无返回值(指定线程池) end
/**
* 异步方法，有返回值
* @return
*/
@Async
@Override
public Future<Integer> asyncReturnDta_1(){
handleBusinessTime();
log.info("asyncReturnDta_1 当前线程名称是：{}",Thread.currentThread().getName());
return new AsyncResult<Integer>(1);
};
/**
* 异步方法，有返回值(指定线程池)
* @return
*/
@Async(ExecutorConstant.simpleExecutor_2)
@Override
public Future<Integer> asyncReturnDta_2(){
handleBusinessTime();
log.info("asyncReturnDta_2 当前线程名称是：{}",Thread.currentThread().getName());
return new AsyncResult<Integer>(1);
};
/**
* 异步方法，有返回值-超时
* @return
*/
@Async
@Override
public Future<Integer> asyncReturnDtaTimeOut(){
handleBusinessTime();
handleBusinessTime();
handleBusinessTime();
handleBusinessTime();
log.info("asyncReturnDta_3 当前线程名称是：{}",Thread.currentThread().getName());
return new AsyncResult<Integer>(1);
};
/**
* 这方法 模拟处理业务或者 去操作数据库 消耗的时间
*/
public static void handleBusinessTime(){
//去数据库查询数据耗时 start
int[] sleepTime = NumberUtil.generateRandomNumber(2000,5000,1);
try {
//Thread.sleep 休眠的时候 相当于 业务操作，或者请求数据库的需要消耗的时间
Thread.sleep(sleepTime[0]);
} catch (InterruptedException e) {
e.printStackTrace();
}
//去数据库查询数据耗时 end
}
}
TestAsyncController
@Slf4j
@RestController
@RequestMapping(value = "/v1/async")
public class TestAsyncController {
@Autowired
ITestAsyncService testAsyncService;
@ApiOperation(value = "调用接口")
@RequestMapping(value = "/test", method = RequestMethod.GET)
public Resp<Integer> test() throws ExecutionException, InterruptedException {
log.info("asyncFunction_1 start");
testAsyncService.asyncFunction_1();
log.info("asyncFunction_1 start");
log.info("asyncFunction_2 start");
testAsyncService.asyncFunction_2();
log.info("asyncFunction_2 end");
log.info("asyncFunction_3 start");
testAsyncService.asyncFunction_3();
log.info("asyncFunction_3 end");
log.info("asyncReturnDta_1 & asyncReturnDta_2 start");
Future<Integer> future = testAsyncService.asyncReturnDta_1();
testAsyncService.asyncReturnDta_2();
log.info("asyncReturnDta_1 & asyncReturnDta_2 end");
Integer resp = future.get();
log.info("future.get() resp:{}",resp);
return Resp.buildDataSuccess(resp);
}
@ApiOperation(value = "调用接口-超时")
@RequestMapping(value = "/async_timeOut", method = RequestMethod.GET)
public Resp<Integer> async_timeOut() throws ExecutionException, InterruptedException {
TimeInterval timeInterval = DateUtil.timer();
log.info("asyncReturnDtaTimeOut start");
Future<Integer> future = testAsyncService.asyncReturnDtaTimeOut();
log.info("asyncReturnDtaTimeOut end");
Integer resp = null;
try {
//一秒内 返回不了数据就报错
resp = future.get(1, TimeUnit.SECONDS);
} catch (TimeoutException e) {
resp = -1;//请求超时了，相当于熔断，服务降级
log.error("asyncReturnDtaTimeOut future.get(1, TimeUnit.SECONDS) timeout:",e);
}
log.info("future.get() resp:{} 耗时：{}毫秒",resp,timeInterval.intervalRestart());
return Resp.buildDataSuccess(resp);
}
}
/v1/async/test 接口：
2021-06-20 21:09:30.490 INFO 14207 --- [nio-8666-exec-7] c.e.m.controller.TestAsyncController : asyncFunction_1 start
2021-06-20 21:09:30.490 INFO 14207 --- [nio-8666-exec-7] c.e.m.controller.TestAsyncController : asyncFunction_1 start
2021-06-20 21:09:30.490 INFO 14207 --- [nio-8666-exec-7] c.e.m.controller.TestAsyncController : asyncFunction_2 start
2021-06-20 21:09:30.491 INFO 14207 --- [nio-8666-exec-7] c.e.m.controller.TestAsyncController : asyncFunction_2 end
2021-06-20 21:09:30.491 INFO 14207 --- [nio-8666-exec-7] c.e.m.controller.TestAsyncController : asyncFunction_3 start
2021-06-20 21:09:30.491 INFO 14207 --- [nio-8666-exec-7] c.e.m.controller.TestAsyncController : asyncFunction_3 end
2021-06-20 21:09:30.491 INFO 14207 --- [nio-8666-exec-7] c.e.m.controller.TestAsyncController : asyncReturnDta_1 & asyncReturnDta_2 start
2021-06-20 21:09:30.492 INFO 14207 --- [nio-8666-exec-7] c.e.m.controller.TestAsyncController : asyncReturnDta_1 & asyncReturnDta_2 end
2021-06-20 21:09:32.679 INFO 14207 --- [le-1-executor-9] c.e.multi.service.impl.TestAsyncService : asyncFunction_1 当前线程名称是：my-simple-1-executor-9
2021-06-20 21:09:33.454 INFO 14207 --- [le-2-executor-8] c.e.multi.service.impl.TestAsyncService : asyncFunction_3 当前线程名称是：my-simple-2-executor-8
2021-06-20 21:09:33.578 INFO 14207 --- [le-2-executor-9] c.e.multi.service.impl.TestAsyncService : asyncReturnDta_2 当前线程名称是：my-simple-2-executor-9
2021-06-20 21:09:34.101 INFO 14207 --- [e-1-executor-10] c.e.multi.service.impl.TestAsyncService : asyncReturnDta_1 当前线程名称是：my-simple-1-executor-10
2021-06-20 21:09:34.102 INFO 14207 --- [nio-8666-exec-7] c.e.m.controller.TestAsyncController : future.get() resp:1
2021-06-20 21:09:34.357 INFO 14207 --- [le-2-executor-7] c.e.multi.service.impl.TestAsyncService : asyncFunction_2 当前线程名称是：my-simple-2-executor-7
从日志上可以看出，都是异步执行的
/v1/async/async_timeOut 接口：
2021-06-20 21:20:58.886 INFO 14427 --- [nio-8666-exec-1] c.e.m.controller.TestAsyncController : asyncReturnDtaTimeOut start
2021-06-20 21:20:58.890 INFO 14427 --- [nio-8666-exec-1] c.e.m.controller.TestAsyncController : asyncReturnDtaTimeOut end
2021-06-20 21:20:59.899 ERROR 14427 --- [nio-8666-exec-1] c.e.m.controller.TestAsyncController : asyncReturnDtaTimeOut future.get(1, TimeUnit.SECONDS) timeout:java.util.concurrent.TimeoutException: null
at java.util.concurrent.FutureTask.get(FutureTask.java:205) ~[na:1.8.0_231]
at com.example.multi.controller.TestAsyncController.async_timeOut(TestAsyncController.java:69) ~[classes/:na]
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_231]
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_231]
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_231]
at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_231]
at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:197) [spring-web-5.3.8.jar:5.3.8]
at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:141) [spring-web-5.3.8.jar:5.3.8]
at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:106) [spring-webmvc-5.3.8.jar:5.3.8]
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:894) [spring-webmvc-5.3.8.jar:5.3.8]
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:808) [spring-webmvc-5.3.8.jar:5.3.8]
at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:87) [spring-webmvc-5.3.8.jar:5.3.8]
at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:1063) [spring-webmvc-5.3.8.jar:5.3.8]
at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:963) [spring-webmvc-5.3.8.jar:5.3.8]
at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:1006) [spring-webmvc-5.3.8.jar:5.3.8]
at org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:898) [spring-webmvc-5.3.8.jar:5.3.8]
at javax.servlet.http.HttpServlet.service(HttpServlet.java:626) [tomcat-embed-core-9.0.46.jar:4.0.FR]
at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:883) [spring-webmvc-5.3.8.jar:5.3.8]
at javax.servlet.http.HttpServlet.service(HttpServlet.java:733) [tomcat-embed-core-9.0.46.jar:4.0.FR]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:227) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:162) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:53) [tomcat-embed-websocket-9.0.46.jar:9.0.46]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:189) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:162) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.springframework.web.filter.RequestContextFilter.doFilterInternal(RequestContextFilter.java:100) [spring-web-5.3.8.jar:5.3.8]
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119) [spring-web-5.3.8.jar:5.3.8]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:189) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:162) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.springframework.web.filter.FormContentFilter.doFilterInternal(FormContentFilter.java:93) [spring-web-5.3.8.jar:5.3.8]
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119) [spring-web-5.3.8.jar:5.3.8]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:189) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:162) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:201) [spring-web-5.3.8.jar:5.3.8]
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119) [spring-web-5.3.8.jar:5.3.8]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:189) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:162) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:202) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:97) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:542) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:143) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:92) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:78) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:357) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:374) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:65) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:893) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1707) [tomcat-embed-core-9.0.46.jar:9.0.46]
at org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49) [tomcat-embed-core-9.0.46.jar:9.0.46]
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) [na:1.8.0_231]
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) [na:1.8.0_231]
at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61) [tomcat-embed-core-9.0.46.jar:9.0.46]
at java.lang.Thread.run(Thread.java:748) [na:1.8.0_231]2021-06-20 21:20:59.900 INFO 14427 --- [nio-8666-exec-1] c.e.m.controller.TestAsyncController : future.get() resp:-1 耗时：1014毫秒
2021-06-20 21:21:12.105 INFO 14427 --- [le-1-executor-1] c.e.multi.service.impl.TestAsyncService : asyncReturnDta_3 当前线程名称是：my-simple-1-executor-1
从日志上看出，如果future.get(1, TimeUnit.SECONDS) 到了超时时间，直接抛出超时异常，走主线程后续代码。
比较适合 规定时间范围内要返回数据（超时可以根据业务场景，返回一个默认值，或者返回值值就是空的）的业务场景
@Async原理+源码
原理：是通过spring aop + 线程池的方式来实现的
源码：
源码的方法位置是：AsyncExecutionInterceptor.invoke
107行：是获取一个线程池108行：如果没有设置线程池抛出异常113行：是创建一个线程对象 他的run方法执行invocation.proceed()【走实际业务代码】121和124行：走的是统一的异常处理 主要是调用handleUncaughtException方法，SimpleExecutorConfig 实现了AsyncConfigurer接口它就有getAsyncUncaughtExceptionHandler方法，可以重写这个方法，实现自定义的异常处理
下图是AsyncConfigurer接口可以实现的方法：
doSubmit方法：
实际上就是调用线程池的submit方法：
具体代码，我上传到gitee，大家感兴趣可以clone 传送门～
@Async源码参考于：
https://www.jb51.net/article/141542.htm
以上就是spring boot使用@Async异步注解的实现原理+源码的详细内容，更多关于spring boot异步注解的资料请关注我们其它相关文章！
相关推荐
-
spring boot 使用@Async实现异步调用方法
使用@Async实现异步调用 什么是"异步调用"与"同步调用" "同步调用"就是程序按照一定的顺序依次执行,,每一行程序代码必须等上一行代码执行完毕才能执行:"异步调用"则是只要上一行代码执行,无需等待结果的返回就开始执行本身任务. 通常情况下,"同步调用"执行程序所花费的时间比较多,执行效率比较差.所以,在代码本身不存在依赖关系的话,我们可以考虑通过"异步调用"的方式来并发执行. &q
-
Spring Boot利用@Async异步调用：ThreadPoolTaskScheduler线程池的优雅关闭详解
前言 之前分享了一篇关于Spring Boot中使用@Async来实现异步任务和线程池控制的文章:<Spring Boot使用@Async实现异步调用:自定义线程池>.由于最近身边也发现了不少异步任务没有正确处理而导致的不少问题,所以在本文就接前面内容,继续说说线程池的优雅关闭,主要针对ThreadPoolTaskScheduler线程池. 问题现象 在上篇文章的例子Chapter4-1-3中,我们定义了一个线程池,然后利用@Async注解写了3个任务,并指定了这些任务执行使用的线程池.在上文
-
深入理解spring boot异步调用方式@Async
本文主要给大家介绍了关于spring boot异步调用方式@Async的相关内容,分享出来供大家参考学习,下面来一起看看详细的介绍: 1.使用背景 在日常开发的项目中,当访问其他人的接口较慢或者做耗时任务时,不想程序一直卡在耗时任务上,想程序能够并行执行,我们可以使用多线程来并行的处理任务,也可以使用spring提供的异步处理方式@Async. 2.异步处理方式 调用之后,不返回任何数据. 调用之后,返回数据,通过Future来获取返回数据 3.@Async不返回数据 使用@EnableAsyn
-
spring boot中使用@Async实现异步调用任务
什么是"异步调用"? "异步调用"对应的是"同步调用",同步调用指程序按照定义顺序依次执行,每一行程序都必须等待上一行程序执行完成之后才能执行:异步调用指程序在顺序执行时,不等待异步调用的语句返回结果就执行后面的程序. 同步调用 下面通过一个简单示例来直观的理解什么是同步调用: 定义Task类,创建三个处理函数分别模拟三个执行任务的操作,操作消耗时间随机取(10秒内) package com.kfit.task; import java.uti
-
SpringBoot用@Async注解实现异步任务
什么是异步调用? 异步调用是相对于同步调用而言的,同步调用是指程序按预定顺序一步步执行,每一步必须等到上一步执行完后才能执行,异步调用则无需等待上一步程序执行完即可执行. 如何实现异步调用? 多线程,这是很多人第一眼想到的关键词,没错,多线程就是一种实现异步调用的方式. 在非spring目项目中我们要实现异步调用的就是使用多线程方式,可以自己实现Runable接口或者集成Thread类,或者使用jdk1.5以上提供了的Executors线程池. StrngBoot中则提供了很方便的方式执行异步调
-
spring boot使用@Async异步注解的实现原理+源码
1.java的大部分接口的方法都是串行执行的,但是有些业务场景是不需要同步返回结果的,可以把结果直接返回,具体业务异步执行,也有些业务接口是需要并行获取数据,最后把数据聚合在统一返回给前端. 通常我们都是采用多线程的方式来实现上述业务功能,但spring 提供更优雅的方式来实现上述功能,就是@Async 异步注解,在方法上添加@Async,spring就会借助AOP,异步执行方法. 1.如何启用@Async spring boot通过@EnableAsync 注解启用@Async异步注解 实现A
-
Spring Boot之@Async异步线程池示例详解
目录 前言 一. Spring异步线程池的接口类 :TaskExecutor 二.简单使用说明 三.定义通用线程池 1.定义线程池 2.异步方法使用线程池 3.通过xml配置定义线程池 四.异常处理 五.问题 前言 很多业务场景需要使用异步去完成,比如:发送短信通知.要完成异步操作一般有两种: 1.消息队列MQ 2.线程池处理. 我们来看看Spring框架中如何去使用线程池来完成异步操作,以及分析背后的原理. 一. Spring异步线程池的接口类 :TaskExecutor 在Spring4中,
-
Spring Boot 整合单机websocket的步骤 附github源码
websocket 概念 websocket 是一个通信协议,通过单个 TCP 连接提供全双工通信.websocket 连接成功后,服务端和客户可以进行双向通信.不同于 http 通信协议需要每次由客户端发起,服务响应到客户端. websocket 相对轮询也能节约带宽,并且能实时的进行通信. 整合步骤 1. 添加 maven 依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifact
-
Spring Boot利用@Async异步调用：使用Future及定义超时详解
前言 之前连续写了几篇关于使用@Async实现异步调用的内容,也得到不少童鞋的反馈,其中问题比较多的就是关于返回Future的使用方法以及对异步执行的超时控制,所以这篇就来一起讲讲这两个问题的处理. 如果您对于@Async注解的使用还不了解的话,可以看看之前的文章,具体如下: 使用@Async实现异步调用 使用@Async实现异步调用:自定义线程池 使用@Async实现异步调用:资源优雅关闭 定义异步任务 首先,我们先使用@Async注解来定义一个异步任务,这个方法返回Future类型,具体如下
-
Spring Boot + Thymeleaf + Activiti 快速开发平台项目 附源码
项目介绍 基于Layui的后台管理系统模板,扩展Layui原生UI样式,整合第三方开源组件,提供便捷快速的开发方式,延续LayuiAdmin的设计风格,持续完善的样式与组件的维护,基于异步Ajax的菜单构建,相对完善的多标签页,单标签页的共存,为使用者提供相对完善的开发方案,只为成为更好的轮子,项目不定时更新,建议 Star watch 一份 如果你需要无组件整合 与 示例页面 的基础框架,请前往 Pear Admin Layui 基础版本 项目结构 Pear Admin Layui │ ├─a
-
Spring Boot利用@Async如何实现异步调用：自定义线程池
前言 在之前的Spring Boot基础教程系列中,已经通过<Spring Boot中使用@Async实现异步调用>一文介绍过如何使用@Async注解来实现异步调用了.但是,对于这些异步执行的控制是我们保障自身应用健康的基本技能.本文我们就来学习一下,如果通过自定义线程池的方式来控制异步调用的并发. 本文中的例子我们可以在之前的例子基础上修改,也可以创建一个全新的Spring Boot项目来尝试. 定义线程池 第一步,先在Spring Boot主类中定义一个线程池,比如: @SpringBoo
-
spring boot使用@Async注解解决异步多线程入库的问题
目录 前言 项目实况介绍 第一种方式 第二种方式 这里有个坑! 这里有两个坑! 总结 前言 在开发过程中,我们会遇到很多使用线程池的业务场景,例如定时任务使用的就是ScheduledThreadPoolExecutor.而有些时候使用线程池的场景就是会将一些可以进行异步操作的业务放在线程池中去完成,例如在生成订单的时候给用户发送短信,生成订单的结果不应该被发送短信的成功与否所左右,也就是说生成订单这个主操作是不依赖于发送短信这个操作,所以我们就可以把发送短信这个操作置为异步操作.而要想完成异步操
-
Spring Boot 使用WebAsyncTask异步返回结果
在Spring Boot中(Spring MVC)下请求默认都是同步的,一个请求过去到结束都是由一个线程负责的,很多时候为了能够提高吞吐量,需要将一些操作异步化,除了一些耗时的业务逻辑可以异步化,我们的查询接口也是可以做到异步执行. 一个请求到服务上,是用的web容器的线程接收的,比如线程http-nio-8084-exec-1 我们可以使用WebAsyncTask将这个请求分发给一个新的线程去执行,http-nio-8084-exec-1可以去接收其他请求的处理.一旦WebAsyncTask返
-
Java设计模式之代理模式与@Async异步注解失效的解决
目录 JDK动态代理实现自定义异步注解(@Async) SpringAOP实现自定义异步注解 Spring的异步注解@Async失效分析 自定义注解实现方式 JDK动态代理实现自定义异步注解(@Async) 实现思路: 首先自定义一个注解,命名为:ExtAsync 实现一个接口,这个接口的实现类就是被代理类 实现jdk的InvocationHandler接口,根据反射获取目标方法的信息,判断是否有异步注解,如果有则另起一个线程异步执行去. 1.异步注解 @Target({ElementType.