Spring Boot中异步线程池@Async
很多业务场景需要使用异步去完成，比如：发送短信通知。要完成异步操作一般有两种：
1、消息队列MQ
2、线程池处理。
我们来看看Spring框架中如何去使用线程池来完成异步操作，以及分析背后的原理。
一. Spring异步线程池的接口类 ：TaskExecutor
在Spring4中，Spring中引入了一个新的注解@Async，这个注解让我们在使用Spring完成异步操作变得非常方便。
Spring异步线程池的接口类，其实质是
java.util.concurrent.Executor
Spring 已经实现的异常线程池：
1. SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。
2. SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只适用于不需要多线程的地方
3. ConcurrentTaskExecutor：Executor的适配类，不推荐使用。如果ThreadPoolTaskExecutor不满足要求时，才用考虑使用这个类
4. SimpleThreadPoolTaskExecutor：是Quartz的SimpleThreadPool的类。线程池同时被quartz和非quartz使用，才需要使用此类
5. ThreadPoolTaskExecutor ：最常使用，推荐。 其实质是对java.util.concurrent.ThreadPoolExecutor的包装，
二、简单使用说明
Spring中用@Async注解标记的方法，称为异步方法。在spring boot应用中使用@Async很简单：
1、调用异步方法类上或者启动类加上注解@EnableAsync
2、在需要被异步调用的方法外加上@Async
3、所使用的@Async注解方法的类对象应该是Spring容器管理的bean对象；
启动类加上注解@EnableAsync：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
@SpringBootApplication
@EnableAsync
public class CollectorApplication {
public static void main(String[] args) throws Exception {
SpringApplication.run(CollectorApplication.class, args);
}
}在需要被异步调用的方法外加上@Async，同时类AsyncService加上注解@Service或者@Component，使其对象成为Spring容器管理的bean对象；
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
@Service
@Transactional
public class AsyncService {
@Async
public void asyncMethod(String s) {
System.out.println("receive:" + s);
}
public void test() {
System.out.println("test");
asyncMethod();//同一个类里面调用异步方法
}
@Async
public void test2() {
AsyncService asyncService = context.getBean(AsyncService.class);
asyncService.asyncMethod();//异步
}
/**
* 异布调用返回Future
*/
@Async
public Future asyncInvokeReturnFuture(int i) {
System.out.println("asyncInvokeReturnFuture, parementer="+ i);
Future future;
try {
Thread.sleep(1000 * 1);
future = new AsyncResult("success:" + i);
} catch (InterruptedException e) {
future = new AsyncResult("error");
}
return future;
}
}
//异步方法和普通的方法调用相同
asyncService.asyncMethod("123");
Future future = asyncService.asyncInvokeReturnFuture(100);
System.out.println(future.get()); 如果将一个类声明为异步类@Async，那么这个类对外暴露的方法全部成为异步方法。
@Async
@Service
public class AsyncClass {
public AsyncClass() {
System.out.println("----init AsyncClass----");
}
volatile int index = 0;
public void foo() {
System.out.println("asyncclass foo, index:" + index);
}
public void foo(int i) {
this.index = i;
System.out.println("asyncclass foo, index:" + i);
}
public void bar(int i) {
this.index = i;
System.out.println("asyncclass bar, index:" + i);
}
}这里需要注意的是：
1、同一个类里面调用异步方法不生效：原因默认类内的方法调用不会被aop拦截，即调用方和被调用方是在同一个类中，是无法产生切面的，该对象没有被Spring容器管理。即@Async方法不生效。
解决办法：如果要使同一个类中的方法之间调用也被拦截，需要使用spring容器中的实例对象，而不是使用默认的this，因为通过bean实例的调用才会被spring的aop拦截
本例使用方法：AsyncService asyncService = context.getBean(AsyncService.class); 然后使用这个引用调用本地的方法即可达到被拦截的目的
备注：这种方法只能拦截protected，default，public方法，private方法无法拦截。这个是spring aop的一个机制。
2、如果不自定义异步方法的线程池默认使用SimpleAsyncTaskExecutor。SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。并发大的时候会产生严重的性能问题。
3、异步方法返回类型只能有两种：void和
java.util.concurrent.Future。
1）当返回类型为void的时候，方法调用过程产生的异常不会抛到调用者层面，
可以通过注
AsyncUncaughtExceptionHandler来捕获此类异常
2）当返回类型为Future的时候，方法调用过程产生的异常会抛到调用者层面
三、定义通用线程池
自定义线程池，可对系统中线程池更加细粒度的控制，方便调整线程池大小配置，线程执行异常控制和处理。在设置系统自定义线程池代替默认线程池时，虽可通过多种模式设置，但替换默认线程池最终产生的线程池有且只能设置一个（不能设置多个类继承 AsyncConfigurer）。自定义线程池有如下方式：
- 重新实现接口 AsyncConfigurer；
- 继承 AsyncConfigurerSupport；
- 配置由自定义的 TaskExecutor 替代内置的任务执行器。
通过查看 Spring 源码关于 @Async 的默认调用规则，会优先查询源码中实现 AsyncConfigurer 这个接口的类，实现这个接口的类为 AsyncConfigurerSupport。但默认配置的线程池和异步处理方法均为空，所以，无论是继承或者重新实现接口，都需指定一个线程池。且重新实现 public Executor getAsyncExecutor () 方法。
实现接口 AsyncConfigurer
@Configuration
public class AsyncConfiguration implements AsyncConfigurer {
@Bean("taskExecutor")
public ThreadPoolTaskExecutor executor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
int corePoolSize = 10;
executor.setCorePoolSize(corePoolSize);
int maxPoolSize = 50;
executor.setMaxPoolSize(maxPoolSize);
int queueCapacity = 10;
executor.setQueueCapacity(queueCapacity);
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.setThreadNamePrefix( "asyncServiceExecutor-");
executor.setWaitForTasksToCompleteOnShutdown(true);
executor.setAwaitTerminationSeconds(awaitTerminationSeconds);
executor.initialize();
return executor;
}
@Override
public Executor getAsyncExecutor() {
return executor();
}
}继承 AsyncConfigurerSupport
Configuration
@EnableAsync
class SpringAsyncConfigurer extends AsyncConfigurerSupport {
@Bean
public ThreadPoolTaskExecutor asyncExecutor() {
ThreadPoolTaskExecutor threadPool = new ThreadPoolTaskExecutor();
threadPool.setCorePoolSize(3);
threadPool.setMaxPoolSize(3);
threadPool.setWaitForTasksToCompleteOnShutdown(true);
threadPool.setAwaitTerminationSeconds(60 * 15);
return threadPool;
}
@Override
public Executor getAsyncExecutor() {
return asyncExecutor;
}
}配置自定义的 TaskExecutor (建议采用方式)
在Spring Boot主类中定义一个线程池，public Executor taskExecutor() 方法用于自定义自己的线程池，线程池前缀”taskExecutor-”。如果不定义，则使用系统默认的线程池。
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
@EnableAsync
@Configuration
class TaskPoolConfig {
@Bean
public Executor taskExecutor1() {
ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor();
pool.setCorePoolSize(5); //线程池活跃的线程数
pool.setMaxPoolSize(10); //线程池最大活跃的线程数
pool.setWaitForTasksToCompleteOnShutdown(true);
pool.setThreadNamePrefix("defaultExecutor");
return pool;
}
@Bean("taskExecutor")
public Executor taskExecutor2() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(20);
executor.setQueueCapacity(200);
executor.setKeepAliveSeconds(60);
executor.setThreadNamePrefix("taskExecutor-");
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.setWaitForTasksToCompleteOnShutdown(true);
executor.setAwaitTerminationSeconds(60);
return executor;
}
}
}上面我们通过ThreadPoolTaskExecutor创建了一个线程池，同时设置了如下参数：
核心线程数10：线程池创建时初始化的线程数
最大线程数20：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
缓冲队列200：用来缓冲执行任务的队列
允许线程的空闲时间60秒：超过了核心线程数之外的线程，在空闲时间到达之后会被销毁
线程池名的前缀：设置好了之后可以方便我们定位处理任务所在的线程池
线程池对拒绝任务的处理策略：此处采用了CallerRunsPolicy策略，当线程池没有处理能力的时候，该策略会直接在execute方法的调用线程中运行被拒绝的任务；如果执行程序已被关闭，则会丢弃该任务
设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean
设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住
也可以单独类来配置线程池：
/**
* 线程池参数配置，多个线程池实现线程池隔离，@Async注解，默认使用系统自定义线程池，可在项目中设置多个线程池，在异步调用的时候，指明需要调用的线程池名称，比如：@Async("taskName")
**/
@EnableAsync
@Configuration
public class TaskPoolConfig {
@Bean("taskExecutor")
public Executor taskExecutor() {
//返回可用处理器的Java虚拟机的数量 12
int i = Runtime.getRuntime().availableProcessors();
System.out.println("系统最大线程数 ： " + i);
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
//核心线程池大小
executor.setCorePoolSize(16);
//最大线程数
executor.setMaxPoolSize(20);
//配置队列容量，默认值为Integer.MAX_VALUE
executor.setQueueCapacity(99999);
//活跃时间
executor.setKeepAliveSeconds(60);
//线程名字前缀
executor.setThreadNamePrefix("asyncServiceExecutor -");
//设置此执行程序应该在关闭时阻止的最大秒数，以便在容器的其余部分继续关闭之前等待剩余的任务完成他们的执行
executor.setAwaitTerminationSeconds(60);
//等待所有的任务结束后再关闭线程池
executor.setWaitForTasksToCompleteOnShutdown(true);
return executor;
}
}四、异步方法使用线程池
@Async(“线程池名称”)，指定value使用自己定义的线程池：
只需要在@Async注解中指定线程池名即可
@Component
public class Task {
//默认使用线程池
@Async
public void doTaskOne() throws Exception {
System.out.println("开始做任务");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
System.out.println("完成任务耗时：" + (end - start) + "毫秒");
}
//根据Bean Name指定特定线程池
@Async("taskExecutor")
public void doTaskOne() throws Exception {
System.out.println("开始做任务");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
System.out.println("完成任务耗时：" + (end - start) + "毫秒");
}
}注意事项（一定注意）
在使用@Async注解时，很多小伙伴都会发现异步使用失败。主要原因是异步方法的定义出了问题。
1、异步方法不能使用static修饰
2、异步类没有使用@Component注解（或其他注解）导致spring无法扫描到异步类
3、异步方法和调用异步方法的方法不能在同一个类
4、类中需要使用@Autowired或@Resource等注解自动注入，不能自己手动new对象
5、如果使用SpringBoot框架必须在启动类中增加@EnableAsync注解