Spring使用@Async注解
Spring使用@Async注解
本文讲述@Async注解，在Spring体系中的应用。本文仅说明@Async注解的应用规则，对于原理，调用逻辑，源码分析，暂不介绍。对于异步方法调用，从Spring3开始提供了@Async注解，该注解可以被标注在方法上，以便异步地调用该方法。调用者将在调用时立即返回，方法的实际执行将提交给Spring TaskExecutor的任务中，由指定的线程池中的线程执行。
在项目应用中，@Async调用线程池，推荐使用自定义线程池的模式。自定义线程池常用方案：重新实现接口AsyncConfigurer。
简介
应用场景
同步： 同步就是整个处理过程顺序执行，当各个过程都执行完毕，并返回结果。
异步： 异步调用则是只是发送了调用的指令，调用者无需等待被调用的方法完全执行完毕；而是继续执行下面的流程。例如， 在某个调用中，需要顺序调用 A, B, C三个过程方法；如他们都是同步调用，则需要将他们都顺序执行完毕之后，方算作过程执行完毕； 如B为一个异步的调用方法，则在执行完A之后，调用B，并不等待B完成，而是执行开始调用C，待C执行完毕之后，就意味着这个过程执行完毕了。在Java中，一般在处理类似的场景之时，都是基于创建独立的线程去完成相应的异步调用逻辑，通过主线程和不同的业务子线程之间的执行流程，从而在启动独立的线程之后，主线程继续执行而不会产生停滞等待的情况。
Spring 已经实现的异常线程池
- SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，默认每次调用都会创建一个新的线程。
- SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只适用于不需要多线程的地方。
- ConcurrentTaskExecutor：Executor的适配类，不推荐使用。如果ThreadPoolTaskExecutor不满足要求时，才用考虑使用这个类。
- SimpleThreadPoolTaskExecutor：是Quartz的SimpleThreadPool的类。线程池同时被quartz和非quartz使用，才需要使用此类。
- ThreadPoolTaskExecutor ：最常使用，推荐。 其实质是对java.util.concurrent.ThreadPoolExecutor的包装。
异步的方法有：
- 最简单的异步调用，返回值为void
- 带参数的异步调用，异步方法可以传入参数
- 存在返回值，常调用返回Future
1.Java中创建线程池
ThreadPoolExecutor类介绍
jdk1.8 源码 删减部分内容
package java.util.concurrent;
/**
* @param corePoolSize 核心线程数 -> 线程池中保持的线程数量,即使它们是空闲的也不会销毁,
* 除非设置了{@code allowCoreThreadTimeOut}核心线程超时时间
* @param maximumPoolSize 最大线程数 -> 线程池中允许接收的最大线程数量
* 如果设定的数量比系统支持的线程数还要大时,会抛出OOM(OutOfMemoryError)异常
* @param keepAliveTime 最大存活时间 -> 当前线程数大于核心线程数的时候,
* 其他多余的线程接收新任务之前的最大等待时间,超过时间没有新任务就会销毁.
* @param unit {@code keepAliveTime}最大存活时间的单位.eg:TimeUnit.SECONDS
* @param workQueue 工作队列 -> 保存任务直到任务被提交到线程池的线程中执行.
* @param threadFactory 线程工厂 -> 当线程池需要创建线程得时候会从线程工厂获取新的实例.
* (自定义ThreadFactory可以跟踪线程池究竟何时创建了多少线程,也可以自定义线程的名称、
* 组以及优先级等信息,甚至可以任性的将线程设置为守护线程.
* 总之,自定义ThreadFactory可以更加自由的设置线程池中所有线程的状态。)
* @param handler 当线程数量等于最大线程数并且工作队列已满的时候,再有新的任务添加进来就会进入这个handler,
* 可以理解为设置拒绝策略（此处不清楚的可以看一下ThreadPoolExecutor中的execute方法的注释）
*/
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
}
ThreadPoolExecutor的执行流程如下：
- 主线程提交新任务到线程池
- 线程池判断当前线程池的线程数和核心线程数的大小,小于就新建线程处理请求;否则继续判断当前工作队列是否已满
- 如果当前工作队列未满就将任务放到工作队列中;否则继续判断当前线程池的线程数和最大线程数的大小
- 如果当前线程池的线程数小于最大线程数就新建线程处理请求;否则就调用RejectedExecutionHandler来做拒绝处理.
jdk默认提供四种RejectedExecutionHandler接口的实现
- AbortPolicy: 直接抛出RejectedExecutionException异常
- CallerRunsPolicy: 交由主线程执行
- DiscardOldestPolicy: 抛弃工作队列中旧的任务,将新任务添加进队列;会导致被丢弃的任务无法再次被执行
- DiscardPolicy: 抛弃当前任务;会导致被抛弃的任务无法再次被执行
2.Spring中创建线程池
ThreadPoolTaskExecutor类介绍
package org.springframework.scheduling.concurrent;
public class ThreadPoolTaskExecutor {
private final Object poolSizeMonitor = new Object(); // 线程池大小锁,保证获取的当前线程池大小的正确性
private int corePoolSize = 1; // 核心线程数
private int maxPoolSize = 2147483647; // 最大线程数
private int keepAliveSeconds = 60; // 最大存活时间
private int queueCapacity = 2147483647; // 工作队列大小
private boolean allowCoreThreadTimeOut = false; // 是否允许核心线程超时,false不允许
private TaskDecorator taskDecorator; // 围绕任务的调用设置一些执行上下文,或者为任务执行提供一些监视/统计
private ThreadPoolExecutor threadPoolExecutor; // java中的线程池创建类
｝
从源码中可以看出ThreadPoolTaskExecutor就是在java中ThreadPoolExecutor的基础上封装的
3.线程池使用示例
3.1基本介绍
1、Spring中启用@Async
// 1、基于Java配置的启用方式：
@Configuration
@EnableAsync
public class SpringAsyncConfig { ... }
// 2、Spring boot启用：
@EnableAsync
@EnableTransactionManagement
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
2、@Async应用默认线程池
Spring应用默认的线程池，指在@Async注解在使用时，不指定线程池的名称。查看源码，@Async的默认线程池为SimpleAsyncTaskExecutor。
3、无返回值调用
基于@Async无返回值调用，直接在使用类，使用方法（建议在使用方法）上，加上注解。若需要抛出异常，需手动new一个异常抛出。
/**
* 带参数的异步调用 异步方法可以传入参数
* 对于返回值是void，异常会被AsyncUncaughtExceptionHandler处理掉
* @param s
*/
@Async
public void asyncInvokeWithException(String s) {
log.info("asyncInvokeWithParameter, parementer={}", s);
throw new IllegalArgumentException(s);
}
4、有返回值Future调用
/**
* 异常调用返回Future
* 对于返回值是Future，不会被AsyncUncaughtExceptionHandler处理，需要我们在方法中捕获异常并处理
* 或者在调用方在调用Futrue.get时捕获异常进行处理
*
* @param i
* @return
*/
@Async
public Future<String> asyncInvokeReturnFuture(int i) {
log.info("asyncInvokeReturnFuture, parementer={}", i);
Future<String> future;
try {
Thread.sleep(1000 * 1);
future = new AsyncResult<String>("success:" + i);
throw new IllegalArgumentException("a");
} catch (InterruptedException e) {
future = new AsyncResult<String>("error");
} catch(IllegalArgumentException e){
future = new AsyncResult<String>("error-IllegalArgumentException");
}
return future;
}
5、有返回值CompletableFuture调用
CompletableFuture 并不使用@Async注解，可达到调用系统线程池处理业务的功能。
JDK5新增了Future接口，用于描述一个异步计算的结果。虽然 Future 以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的初衷相违背，轮询的方式又会耗费无谓的 CPU 资源，而且也不能及时地得到计算结果。
- CompletionStage代表异步计算过程中的某一个阶段，一个阶段完成以后可能会触发另外一个阶段
- 一个阶段的计算执行可以是一个Function，Consumer或者Runnable。比如：stage.thenApply(x -> square(x)).thenAccept(x -> System.out.print(x)).thenRun(() -> System.out.println())
- 一个阶段的执行可能是被单个阶段的完成触发，也可能是由多个阶段一起触发
在Java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。
- 它可能代表一个明确完成的Future，也有可能代表一个完成阶段（ CompletionStage ），它支持在计算完成以后触发一些函数或执行某些动作。
- 它实现了Future和CompletionStage接口
6、默认线程池的弊端
在线程池应用中，参考阿里巴巴java开发规范：**线程池不允许使用Executors去创建，不允许使用系统默认的线程池，推荐通过ThreadPoolExecutor的方式，这样的处理方式让开发的工程师更加明确线程池的运行规则，规避资源耗尽的风险。Executors各个方法的弊端：
- newFixedThreadPool和newSingleThreadExecutor：主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。
- newCachedThreadPool和newScheduledThreadPool：要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。
@Async默认异步配置使用的是SimpleAsyncTaskExecutor，该线程池默认来一个任务创建一个线程，若系统中不断的创建线程，最终会导致系统占用内存过高，引发OutOfMemoryError错误。针对线程创建问题，SimpleAsyncTaskExecutor提供了限流机制，通过concurrencyLimit属性来控制开关，当concurrencyLimit>=0时开启限流机制，默认关闭限流机制即concurrencyLimit=-1，当关闭情况下，会不断创建新的线程来处理任务。基于默认配置，SimpleAsyncTaskExecutor并不是严格意义的线程池，达不到线程复用的功能。
3.2使用ThreadPoolTaskExecutor
1、pom文件
<!--添加springboot-web依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--添加springboot-test测试依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
2、config类
我们需要通过SpringBoot的配置类来配置线程池的Bean和对应的参数
@Configuration
@EnableAsync // 允许使用异步方法
public class ThreadPoolConfig {
@Bean
public Executor threadPoolTaskExecutor() {
ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
// 设置核心线程数
threadPoolTaskExecutor.setCorePoolSize(5);
// 设置最大线程数
threadPoolTaskExecutor.setMaxPoolSize(5);
// 设置工作队列大小
threadPoolTaskExecutor.setQueueCapacity(2000);
// 设置线程名称前缀
threadPoolTaskExecutor.setThreadNamePrefix("threadPoolTaskExecutor-->");
// 设置拒绝策略.当工作队列已满,线程数为最大线程数的时候,接收新任务抛出RejectedExecutionException异常
threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
// 初始化线程池
threadPoolTaskExecutor.initialize();
return threadPoolTaskExecutor;
}
// @Override
// public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
// return new MyAsyncExceptionHandler();
// }
//
// private static class MyAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
//
// /**
// * 此方法只会处理线程运行异常
// */
// @Override
// public void handleUncaughtException(Throwable throwable, Method method, Object... objects) {
// log.warn("<<<<<>>>>", throwable.getMessage());
// log.warn("<<<<<>>>>", method.getName());
// for (Object param : objects) {
// log.warn("<<<<<>>>>", param);
// }
// }
// }
/**
* 简写方式
*
* @return
*/
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return (throwable, method, params) -> {
log.warn("<<<<<>>>>" , throwable.getMessage());
log.warn("<<<<<>>>>" , method.getName());
for (Object param : params) {
log.warn("<<<<<>>>>" , param);
}
};
}
}
3、Application
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
4、调用方法
@Slf4j
@Service
public class AsyncService {
@Async
public void noContent() {
log.info("这是一个无返回值的方法");
}
@Async
public void noContentHasException(String s) {
log.info("这是一个有参({})无返回值的方法, 但是有异常的方法", s);
throw new RuntimeException("异步运行时异常");
}
@Async
public CompletableFuture<String> haveContent() {
String str = "返回值";
log.info("这是一个有返回值的方法，返回值为：{}", str);
return CompletableFuture.completedFuture(str);
}
}
- 测试类
@RunWith(SpringRunner.class)
@SpringBootTest
public class AsyncTest {
@Autowired
private AsyncService asyncService;
@Test
public void test() {
System.out.println("-----------无参无返回值,方法执行-----------");
asyncService.noContent();
System.out.println("-----------无参无返回值,方法执行完成-----------");
System.out.println("-----------有参无返回值有异常,方法执行-----------");
asyncService.noContentHasException("我是参数");
System.out.println("-----------有参无返回值有异常,方法执行完成-----------");
System.out.println("-----------无参有返回值,方法执行-----------");
CompletableFuture<String> str = asyncService.haveContent();
try {
System.out.println(str.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
System.out.println("-----------无参有返回值,方法执行完成-----------");
// 抛出非异步异常
throw new RuntimeException("非异步运行时异常");
}
}
- 输出
-----------无参无返回值,方法执行-----------
-----------无参无返回值,方法执行完成-----------
-----------有参无返回值有异常,方法执行-----------
-----------有参无返回值有异常,方法执行完成-----------
-----------无参有返回值,方法执行-----------
2019-12-27 11:32:23.367 INFO 452 --- [askExecutor-->3] c.alsb.exception.service.impl.AsyncService : 这是一个有返回值的方法，返回值为：返回值
2019-12-27 11:32:23.367 INFO 452 --- [askExecutor-->1] c.alsb.exception.service.impl.AsyncService : 这是一个无返回值的方法
2019-12-27 11:32:23.367 INFO 452 --- [askExecutor-->2] c.alsb.exception.service.impl.AsyncService : 这是一个有参(我是参数)无返回值的方法, 但是有异常的方法
返回值
-----------无参有返回值,方法执行完成-----------
2019-12-27 11:32:23.368 WARN 452 --- [askExecutor-->2] c.a.exception.config.ThreadPoolConfig : <<<<<<Exception message : 异步运行时异常 >>>>>
2019-12-27 11:32:23.368 WARN 452 --- [askExecutor-->2] c.a.exception.config.ThreadPoolConfig : <<<<<<Method name : noContentHasException >>>>>
2019-12-27 11:32:23.368 WARN 452 --- [askExecutor-->2] c.a.exception.config.ThreadPoolConfig : <<<<<<Parameter value : 我是参数 >>>>>
java.lang.RuntimeException: 非异步运行时异常
at com.alsb.exception.AsyncTest.test(AsyncTest.java:43)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
..................................
注意：因为显示名称长度限制的原因我们看到的是askExecutor–>1,
但是通过在方法中打印当前线程的名字得知确实是我们设置的线程threadPoolTaskExecutor–>1
5、获取异步返回值get方法介绍
/**
* 如有必要，最多等待给定时间以完成此将来，然后返回其结果（如果有）。
*
* @param timeout 等待的最长时间
* @param unit 超时参数的时间单位
* @return 结果值
* @throws CancellationException 如果这个未来被取消了
* @throws ExecutionException 如果这个未来异常完成
* @throws InterruptedException 如果当前线程在等待时被中断
* @throws TimeoutException 如果等待超时
*/
public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
Object r;
long nanos = unit.toNanos(timeout);
return reportGet((r = result) == null ? timedGet(nanos) : r);
}
3.3使用ThreadPoolExecutor
1、在config类中增加如下配置
@Bean
public Executor myThreadPool() {
// 设置核心线程数
int corePoolSize = 5;
// 设置最大线程数
int maxPoolSize = 5;
// 设置工作队列大小
int queueCapacity = 2000;
// 最大存活时间
long keepAliveTime = 30;
// 设置线程名称前缀
String threadNamePrefix = "myThreadPool-->";
// 设置自定义拒绝策略.当工作队列已满,线程数为最大线程数的时候,接收新任务抛出RejectedExecutionException异常
RejectedExecutionHandler rejectedExecutionHandler = new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
throw new RejectedExecutionException("自定义的RejectedExecutionHandler");
}
};
// 自定义线程工厂
ThreadFactory threadFactory = new ThreadFactory() {
private int i = 1;
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r);
thread.setName(threadNamePrefix + i);
i++;
return thread;
}
};
// 初始化线程池
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maxPoolSize,
keepAliveTime, TimeUnit.SECONDS, new LinkedBlockingQueue<>(queueCapacity),
threadFactory, rejectedExecutionHandler);
return threadPoolExecutor;
}
可以看到我们在config类中配置了两个线程池,如果我们想要指定使用其中一个线程池的需使用如下方式
当未指明使用哪个线程池的时候会优先使用ThreadPoolTaskExecutor
同时也可以配置bean的名称@Bean(“myThreadPool”)
2、在AsyncService类中添加方法
@Async("myThreadPool")
public void myThreadPool() {
log.info("测试ThreadPoolExecutor，线程名称：{}", Thread.currentThread().getName());
}
3、测试
@Test
public void testMyThreadPool() {
System.out.println("myThreadPool方法运行中");
asyncService.myThreadPool();
}
输出
myThreadPool方法运行中
2019-12-27 13:58:42.136 INFO 19112 --- [yThreadPool-->1] c.alsb.exception.service.impl.AsyncService : 测试ThreadPoolExecutor，线程名称：myThreadPool-->1
3.4 自定义ThreadPoolTaskExecutor
1、创建MyThreadPoolTaskExecutor
@Slf4j
public class MyThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {
@Override
public void execute(Runnable task) {
logThreadPoolStatus();
super.execute(task);
}
@Override
public void execute(Runnable task, long startTimeout) {
logThreadPoolStatus();
super.execute(task, startTimeout);
}
@Override
public Future<?> submit(Runnable task) {
logThreadPoolStatus();
return super.submit(task);
}
@Override
public <T> Future<T> submit(Callable<T> task) {
logThreadPoolStatus();
return super.submit(task);
}
@Override
public ListenableFuture<?> submitListenable(Runnable task) {
logThreadPoolStatus();
return super.submitListenable(task);
}
@Override
public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
logThreadPoolStatus();
return super.submitListenable(task);
}
/**
* 在线程池运行的时候输出线程池的基本信息
*/
private void logThreadPoolStatus() {
log.info("核心线程数:{}, 最大线程数:{}, 当前线程数: {}, 活跃的线程数: {}",
getCorePoolSize(), getMaxPoolSize(), getPoolSize(), getActiveCount());
}
}
我们可以在自定义的ThreadPoolTaskExecutor中,输出一些线程池的当前状态,包括所有上面介绍的参数.
2、在config类中增加配置
@Bean("myThreadPoolTaskExecutor")
public Executor myThreadPoolTaskExecutor() {
ThreadPoolTaskExecutor threadPoolTaskExecutor = new MyThreadPoolTaskExecutor();
// 设置核心线程数
threadPoolTaskExecutor.setCorePoolSize(5);
// 设置最大线程数
threadPoolTaskExecutor.setMaxPoolSize(5);
// 设置工作队列大小
threadPoolTaskExecutor.setQueueCapacity(2000);
// 设置线程名称前缀
threadPoolTaskExecutor.setThreadNamePrefix("myThreadPoolTaskExecutor-->");
// 设置拒绝策略.当工作队列已满,线程数为最大线程数的时候,接收新任务抛出RejectedExecutionException异常
threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
// 初始化线程池
threadPoolTaskExecutor.initialize();
return threadPoolTaskExecutor;
}
只需将ThreadPoolTaskExecutor的实例化对象换成自定义的即可
3.5基于@Async返回值的调用
1、增加一个实体对象
public class HelloEntity {
private String helloStr;
public String getHelloStr() {
return helloStr;
}
public void setHelloStr(String helloStr) {
this.helloStr = helloStr;
}
}
2、在Asuncservice中增加以下方法
@Async("myThreadPoolTaskExecutor")
public Future<HelloEntity> getHelloString() {
log.info("start getHelloString");
HelloEntity helloEntity = new HelloEntity();
helloEntity.setHelloStr("Say hello to little wang");
System.out.println(Thread.currentThread().getName());
log.info("end getHelloString");
return new AsyncResult<>(helloEntity);
}
AsyncResult 是spring封装的和@Async配合使用的异步返回结果
3、测试
@Test
public void testGetHelloString() throws Exception {
Future<HelloEntity> helloString = asyncService.getHelloString();
HelloEntity helloEntity = helloString.get();
System.out.println(helloEntity.getHelloStr());
}
输出
2019-12-27 14:28:29.188 INFO 2252 --- [ main] c.a.e.config.MyThreadPoolTaskExecutor : 核心线程数:5, 最大线程数:5, 当前线程数: 0, 活跃的线程数: 0
2019-12-27 14:28:29.196 INFO 2252 --- [askExecutor-->1] c.a.exception.service.impl.AsyncService : start getHelloString
myThreadPoolTaskExecutor-->1
2019-12-27 14:28:29.197 INFO 2252 --- [askExecutor-->1] c.a.exception.service.impl.AsyncService : end getHelloString
Say hello to little wang
2019-12-27 14:28:29.206 INFO 2252 --- [ Thread-2] c.a.e.config.MyThreadPoolTaskExecutor : Shutting down ExecutorService 'myThreadPoolTaskExecutor'
2019-12-27 14:28:29.206 INFO 2252 --- [ Thread-2] o.s.s.concurrent.ThreadPoolTaskExecutor : Shutting down ExecutorService 'threadPoolTaskExecutor'
3.5 使用默认配置的线程池
我们不需要配置任何config类只需要在启动类中加上以下注解
@SpringBootApplication
@EnableAsync // 允许使用异步方法
public class ThreadPoolApplication {
public static void main(String[] args) {
SpringApplication.run(ThreadPoolApplication.class, args);
}
}
----------------------
@Async
public void sayHello() {
logger.info("start say hello");
System.out.println(Thread.currentThread().getName());
System.out.println("hello");
logger.info("end say hello");
}
------------------------
@Test
public void testSayHello() throws Exception {
helloService.sayHello();
}
默认使用的就是ThreadPoolTaskExecutor这个类，当我们在项目中使用线程池的时候,还是要根据项目的实际情况来设置线程池的参数