*写在前面：本篇文章是关于使用@Async进行异步任务，并且关于线程池做了一个初步的梳理和总结，包括遇到过的一些坑* ## 在工作中用到的一些线程池 *以下代码已做脱敏处理* **1.newCachedThreadPool** ```java private void startTask(List usersList){ ExecutorService executor = Executors.newCachedThreadPool(); executor.submit(()->{ //do someting }); } ``` **2.newScheduledThreadPool** ```java @Configuration public class ScheduleConfig implements SchedulingConfigurer { @Override public void configureTasks(ScheduledTaskRegistrar taskRegistrar) { //当然了，这里设置的线程池是corePoolSize也是很关键了，自己根据业务需求设定 taskRegistrar.setScheduler(Executors.newScheduledThreadPool(10)); } } ``` 如果在idea中安装了阿里规范插件，就会发现上面两种创建线程池的方式都会报红。原因是：线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。说明：Executors返回的线程池对象的弊端如下： 1. FixedThreadPool和SingleThreadPool: 允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。 2. CachedThreadPool: 允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。其实这里CachedThreadPool和newScheduledThreadPool是一样的，都是因为最大线程数被设置成了Integer.MAX_VALUE。 ```java public ScheduledThreadPoolExecutor(int corePoolSize) { super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue()); } ``` ```java public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue()); } ``` 在源码中可以看的出newCachedThreadPool使用的是synchronousqueue队列，也可以看作是一个长度为1的BlockingQueue所以，再加上最大允许线程数为Integer.MAX_VALUE，就导致可能会创建大量线程导致OOM。同理ScheduledThreadPoolExecutor使用的是DelayedWorkQueue，初始化大小为16。当队列满后就会创建新线程，就导致可能会创建大量线程导致OOM。我们不妨实际来测试一下,以newCachedThreadPool为例，jvm参数-Xms64m -Xmx192m -Xss1024K -XX:MetaspaceSize=64m -XX:MaxMetaspaceSize=128m。 ```java @PostMapping("/newCachedThreadPoolExample") @ResponseBody public void newCachedThreadPoolExample(){ ExecutorService executorService = Executors.newCachedThreadPool(); while (true){ executorService.submit(()->{ log.info("submit:"+LocalDateTime.now()); try { Thread.sleep(1000); }catch (InterruptedException e){ e.printStackTrace(); } }); } } ``` 刚启动时的情况： ![x1.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4a2909631567482d98426ee80205e316~tplv-k3u1fbpfcp-watermark.image) 请求接口后就开始爆炸 ![x2.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/79661652d9b145399bac3b60765aa83b~tplv-k3u1fbpfcp-watermark.image) 然后就开始卡着不动了 ![x3.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b4c1b8f75f514fbcbffe4ca004c10680~tplv-k3u1fbpfcp-watermark.image) 比较尴尬的是一直没有出现报错OOM的情况，就直接卡死了。 ![x4.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1ae047e7fcd9477d9328d8e5e437ea80~tplv-k3u1fbpfcp-watermark.image) **总结** 以上的线程池虽然可以在外部限制的情况下避免OOM等情况，但是还是建议尽量根据自己的业务情况自定义线程池。 ## 使用@Async快速创建一个异步任务 **1. application.yml** 这里是线程池相关配置，先不详细说，同理可以在代码里面配置config。 ## 线程池缓冲队列的选择以上发生的问题大多数都和线程池的缓冲队列有关，选择一个符合自己业务特点的缓冲队列也十分重要。 ![x5'.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7be6c209a6494380bbfdd3c32807af54~tplv-k3u1fbpfcp-watermark.image) ```yml spring: task: execution: pool: # 最大线程数 max-size: 16 # 核心线程数 core-size: 16 # 存活时间 keep-alive: 10s # 队列大小 queue-capacity: 100 # 是否允许核心线程超时 allow-core-thread-timeout: true # 线程名称前缀 thread-name-prefix: async-task- ``` **2.ThreadpoolApplication** 这里需要在 Application上添加 @EnableAsync注解，开启异步任务。如果是选择在代码里面写config，则需要在config文件上添加@EnableAsync注解。 ```java @EnableAsync @SpringBootApplication public class ThreadpoolApplication { public static void main(String[] args) { SpringApplication.run(ThreadpoolApplication.class, args); } } ``` **3.AsyncTask** 编写一个异步任务处理类，在需要开启异步的方法上面添加@Async ```java @Component @Slf4j public class AsyncTask { @Async public void asyncRun() throws InterruptedException { Thread.sleep(10); log.info(Thread.currentThread().getName()+":处理完成"); } } ``` **4.AsyncService** 编写一个调用异步方法的service ```java @Service @Slf4j public class AsyncService { @Autowired private AsyncTask asyncTask; public void asyncSimpleExample() { try { log.info("service start"); asyncTask.asyncRun(); log.info("service end"); }catch (InterruptedException e){ e.printStackTrace(); } } } ``` **5.AsyncController** 编写一个Controller去调用AsyncService ```java /** * @author kurtl */ @Controller @RequestMapping("/") public class AsyncController { @Autowired private AsyncService asyncService; @PostMapping("/asyncSimpleExample") @ResponseBody public void asyncSimpleExample(){ asyncService.asyncSimpleExample(); } } ``` 最后请求这个接口 ![x6.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/70843a06cf3d41f59b38a9fa193d656e~tplv-k3u1fbpfcp-watermark.image) 可以看到，先输出了asyncSimpleExample里面打印的service start与service end，表示service方法先执行完毕了，而异步方法则在调用后进行了一个sleep，service没有同步等待sleep完成，而是直接返回，表示这个是异步任务。至此我们已经通过@Async成功创建的异步任务。 ## 关于@Async和@EnableAsync的原理 *个人觉得源码中很重要的一部分就是源码中的注释，阅读注释也可以帮你快速了解源码的作用等，所有我会把重要的注释稍微翻译一下* **1.@Async源码** ```java @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Async { /** * A qualifier value for the specified asynchronous operation(s). *

May be used to determine the target executor to be used when executing * the asynchronous operation(s), matching the qualifier value (or the bean * name) of a specific {@link java.util.concurrent.Executor Executor} or * {@link org.springframework.core.task.TaskExecutor TaskExecutor} * bean definition. *

When specified on a class-level {@code @Async} annotation, indicates that the * given executor should be used for all methods within the class. Method-level use * of {@code Async#value} always overrides any value set at the class level. * @since 3.1.2 */ /** * 在这些注释中有三个非常重要的部分 * 1.使用@Async的方法只能返回Void 或者 Future类型 * 2.表明了@Async是通过org.springframework.core.task.TaskExecutor * 或者java.util.concurrent.Executor来创建线程池 * 3.写了@Async的作用范围在类上使用@Async会覆盖方法上的@Async */ String value() default ""; } ``` **2.@EnableAsync源码** ```java /** * Enables Spring's asynchronous method execution capability, similar to functionality * found in Spring's {@code } XML namespace. * *

To be used together with @{@link Configuration Configuration} classes as follows, * enabling annotation-driven async processing for an entire Spring application context: * *

 * @Configuration
 * @EnableAsync
 * public class AppConfig {
 *
 * }

* 这里表示需要联合@Configuration注解一起使用，所以@EnableAsync应该 * 添加在线程池Config或者SpringBootApplication 上 * {@code MyAsyncBean} is a user-defined type with one or more methods annotated with * either Spring's {@code @Async} annotation, the EJB 3.1 {@code @javax.ejb.Asynchronous} * annotation, or any custom annotation specified via the {@link #annotation} attribute. * The aspect is added transparently for any registered bean, for instance via this * configuration: * *

 * @Configuration
 * public class AnotherAppConfig {
 *
 *     @Bean
 *     public MyAsyncBean asyncBean() {
 *         return new MyAsyncBean();
 *     }
 * }

* *

By default, Spring will be searching for an associated thread pool definition: * either a unique {@link org.springframework.core.task.TaskExecutor} bean in the context, * or an {@link java.util.concurrent.Executor} bean named "taskExecutor" otherwise. If * neither of the two is resolvable, a {@link org.springframework.core.task.SimpleAsyncTaskExecutor} * 默认情况下spring会先搜索TaskExecutor类型的bean或者名字为 * taskExecutor的Executor类型的bean,都不存在使用 * SimpleAsyncTaskExecutor执行器但是这个SimpleAsyncTaskExecutor实际 * 上是有很大的坑的，建议是自定义一个线程池，这个后面会说 * will be used to process async method invocations. Besides, annotated methods having * * @author Chris Beams * @author Juergen Hoeller * @author Stephane Nicoll * @author Sam Brannen * @since 3.1 * @see Async * @see AsyncConfigurer * @see AsyncConfigurationSelector */ @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Import(AsyncConfigurationSelector.class) public @interface EnableAsync { /** * Indicate the 'async' annotation type to be detected at either class * or method level. *

By default, both Spring's @{@link Async} annotation and the EJB 3.1 * {@code @javax.ejb.Asynchronous} annotation will be detected. *

This attribute exists so that developers can provide their own * custom annotation type to indicate that a method (or all methods of * a given class) should be invoked asynchronously. */ Class annotation() default Annotation.class; /** * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed * to standard Java interface-based proxies. *

Applicable only if the {@link #mode} is set to {@link AdviceMode#PROXY}. *

The default is {@code false}. *

Note that setting this attribute to {@code true} will affect all * Spring-managed beans requiring proxying, not just those marked with {@code @Async}. * For example, other beans marked with Spring's {@code @Transactional} annotation * will be upgraded to subclass proxying at the same time. This approach has no * negative impact in practice unless one is explicitly expecting one type of proxy * vs. another — for example, in tests. * * 这个字段用来表示，是否要创建基于CGLIB的代理，实际上在高版本 * 的spring 上（大概3.x)是自动选择使用jdk动态代理还是CGLIB. * 设置为true时，其它spring管理的bean也会升级到CGLIB代理 */ boolean proxyTargetClass() default false; /** * Indicate how async advice should be applied. *

The default is {@link AdviceMode#PROXY}. * Please note that proxy mode allows for interception of calls through the proxy * only. Local calls within the same class cannot get intercepted that way; an * {@link Async} annotation on such a method within a local call will be ignored * since Spring's interceptor does not even kick in for such a runtime scenario. * For a more advanced mode of interception, consider switching this to * {@link AdviceMode#ASPECTJ}. * 这个字段用来标识异步通知的模式，默认PROXY，当这个字段为 * PROXY的时候，在同一个类中，非异步方法调用异步方法，会导致异 * 步不生效，相反如果，想实现同一个类非异步方法调用异步方法就应 * 该设置为ASPECTJ */ AdviceMode mode() default AdviceMode.PROXY; /** * Indicate the order in which the {@link AsyncAnnotationBeanPostProcessor} * should be applied. *

The default is {@link Ordered#LOWEST_PRECEDENCE} in order to run * after all other post-processors, so that it can add an advisor to * existing proxies rather than double-proxy. * 标明异步注解bean处理器应该遵循的执行顺序，默认最低的优先级 *（Integer.MAX_VALUE，值越小优先级越高） */ int order() default Ordered.LOWEST_PRECEDENCE; } ``` 在上面的源码中，其实最核心的代码只有一句，@Import(AsyncConfigurationSelector.class)，引入了相关的配置。 ```java /** * Selects which implementation of {@link AbstractAsyncConfiguration} should * be used based on the value of {@link EnableAsync#mode} on the importing * {@code @Configuration} class. * * @author Chris Beams * @author Juergen Hoeller * @since 3.1 * @see EnableAsync * @see ProxyAsyncConfiguration */ public class AsyncConfigurationSelector extends AdviceModeImportSelector { private static final String ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME = "org.springframework.scheduling.aspectj.AspectJAsyncConfiguration"; /** * Returns {@link ProxyAsyncConfiguration} or {@code AspectJAsyncConfiguration} * for {@code PROXY} and {@code ASPECTJ} values of {@link EnableAsync#mode()}, * respectively. */ /** * 这整个方法其实就是一个选择器和ImportSelector接口的selectImports()方法很像，基于不同的代理模式，加载不同的配置类 */ @Override @Nullable public String[] selectImports(AdviceMode adviceMode) { switch (adviceMode) { case PROXY: return new String[] {ProxyAsyncConfiguration.class.getName()}; case ASPECTJ: return new String[] {ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME}; default: return null; } } } ``` 接下来我们看看默认的ProxyAsyncConfiguration.class ```java /** * {@code @Configuration} class that registers the Spring infrastructure beans necessary * to enable proxy-based asynchronous method execution. * * @author Chris Beams * @author Stephane Nicoll * @author Juergen Hoeller * @since 3.1 * @see EnableAsync * @see AsyncConfigurationSelector */ @Configuration @Role(BeanDefinition.ROLE_INFRASTRUCTURE) //继承了AbstractAsyncConfiguration类 public class ProxyAsyncConfiguration extends AbstractAsyncConfiguration { @Bean(name = TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME) @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public AsyncAnnotationBeanPostProcessor asyncAdvisor() { Assert.notNull(this.enableAsync, "@EnableAsync annotation metadata was not injected"); //初始化AsyncAnnotationBeanPostProcessor类型的bean AsyncAnnotationBeanPostProcessor bpp = new AsyncAnnotationBeanPostProcessor(); //设置执行器和异常处理器 bpp.configure(this.executor, this.exceptionHandler); Class customAsyncAnnotation = this.enableAsync.getClass("annotation"); //设置annotation if (customAsyncAnnotation != AnnotationUtils.getDefaultValue(EnableAsync.class, "annotation")) { bpp.setAsyncAnnotationType(customAsyncAnnotation); } //设置注解属性 bpp.setProxyTargetClass(this.enableAsync.getBoolean("proxyTargetClass")); bpp.setOrder(this.enableAsync.getNumber("order")); return bpp; } } ``` 这一个类继承了AbstractAsyncConfiguration类，其实也就做了一件事初始化AsyncAnnotationBeanPostProcessor，@Async注解的就是通过AsyncAnnotationBeanPostProcessor这个后置处理器生成一个代理对象来实现异步的，我们先看继承的config。 ```java /** * Abstract base {@code Configuration} class providing common structure for enabling * Spring's asynchronous method execution capability. * * @author Chris Beams * @author Juergen Hoeller * @author Stephane Nicoll * @since 3.1 * @see EnableAsync */ @Configuration public abstract class AbstractAsyncConfiguration implements ImportAware { @Nullable protected AnnotationAttributes enableAsync; //;//enableAsync的注解属性 @Nullable protected Supplier executor; //线程执行器 @Nullable protected Supplier exceptionHandler; //异常处理器和上面的代码对应 @Override //设置注解属性 public void setImportMetadata(AnnotationMetadata importMetadata) { this.enableAsync = AnnotationAttributes.fromMap( importMetadata.getAnnotationAttributes(EnableAsync.class.getName(), false)); if (this.enableAsync == null) { throw new IllegalArgumentException( "@EnableAsync is not present on importing class " + importMetadata.getClassName()); } } /** * Collect any {@link AsyncConfigurer} beans through autowiring. */ @Autowired(required = false) //设置执行器和异常处理器 void setConfigurers(Collection configurers) { if (CollectionUtils.isEmpty(configurers)) { return; } if (configurers.size() > 1) { throw new IllegalStateException("Only one AsyncConfigurer may exist"); } AsyncConfigurer configurer = configurers.iterator().next(); this.executor = configurer::getAsyncExecutor; this.exceptionHandler = configurer::getAsyncUncaughtExceptionHandler; } } ``` 整个代码的结构其实非常明确，我们回到上一个类，看他设置的bean AsyncAnnotationBeanPostProcessor。这个bean很复杂，所以干脆先生成类图。弄清楚baen的生命周期。AsyncAnnotationBeanPostProcessor是一个后置处理器，所以我们先找父类AbstractAdvisingBeanPostProcessor中。 ![x9.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/06524bf436314b208fbaab4da961c6e6~tplv-k3u1fbpfcp-watermark.image) ```java /** * Base class for {@link BeanPostProcessor} implementations that apply a * Spring AOP {@link Advisor} to specific beans. * * @author Juergen Hoeller * @since 3.2 */ @SuppressWarnings("serial") public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSupport implements BeanPostProcessor { @Nullable protected Advisor advisor; protected boolean beforeExistingAdvisors = false; private final Map, Boolean> eligibleBeans = new ConcurrentHashMap<>(256); public void setBeforeExistingAdvisors(boolean beforeExistingAdvisors) { this.beforeExistingAdvisors = beforeExistingAdvisors; } @Override public Object postProcessBeforeInitialization(Object bean, String beanName) { return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) { // 没有通知，或者是AopInfrastructureBean，那么不进行代理 if (this.advisor == null || bean instanceof AopInfrastructureBean) { // Ignore AOP infrastructure such as scoped proxies. return bean; } // 添加advisor if (bean instanceof Advised) { Advised advised = (Advised) bean; if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) { // Add our local Advisor to the existing proxy's Advisor chain... // 这里通过beforeExistingAdvisors决定是将通知添加到所有通知之前还是添加到所有通知之后 // 默认false 在@Async中被设置为true if (this.beforeExistingAdvisors) { advised.addAdvisor(0, this.advisor); } else { advised.addAdvisor(this.advisor); } return bean; } } //构造ProxyFactory代理工厂 if (isEligible(bean, beanName)) { ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName); //添加代理的接口 if (!proxyFactory.isProxyTargetClass()) { evaluateProxyInterfaces(bean.getClass(), proxyFactory); } //设置切面 proxyFactory.addAdvisor(this.advisor); customizeProxyFactory(proxyFactory); //返回代理类 return proxyFactory.getProxy(getProxyClassLoader()); } // No proxy needed. return bean; } //isEligible用于判断这个类或者这个类中的某个方法是否含有注解 protected boolean isEligible(Object bean, String beanName) { return isEligible(bean.getClass()); } } ``` 在上面代码中可以看出来，proxyFactory.addAdvisor(this.advisor);这里持有一个AsyncAnnotationAdvisor类的对象advisor：buildAdvice()方法生成通知，buildPointcut生成切点。定位到这个类的buildPointcut方法中，看看他的切点匹配规则。 ```java @SuppressWarnings("serial") public class AsyncAnnotationAdvisor extends AbstractPointcutAdvisor implements BeanFactoryAware { private Advice advice; private Pointcut pointcut; /** * Create a new {@code AsyncAnnotationAdvisor} for bean-style configuration. */ public AsyncAnnotationAdvisor() { this((Supplier) null, (Supplier) null); } @SuppressWarnings("unchecked") public AsyncAnnotationAdvisor( @Nullable Executor executor, @Nullable AsyncUncaughtExceptionHandler exceptionHandler) { this(SingletonSupplier.ofNullable(executor), SingletonSupplier.ofNullable(exceptionHandler)); } @SuppressWarnings("unchecked") public AsyncAnnotationAdvisor( @Nullable Supplier executor, @Nullable Supplier exceptionHandler) { Set> asyncAnnotationTypes = new LinkedHashSet<>(2); asyncAnnotationTypes.add(Async.class); try { asyncAnnotationTypes.add((Class) ClassUtils.forName("javax.ejb.Asynchronous", AsyncAnnotationAdvisor.class.getClassLoader())); } catch (ClassNotFoundException ex) { // If EJB 3.1 API not present, simply ignore. } this.advice = buildAdvice(executor, exceptionHandler); this.pointcut = buildPointcut(asyncAnnotationTypes); } public void setAsyncAnnotationType(Class asyncAnnotationType) { Assert.notNull(asyncAnnotationType, "'asyncAnnotationType' must not be null"); Set> asyncAnnotationTypes = new HashSet<>(); asyncAnnotationTypes.add(asyncAnnotationType); this.pointcut = buildPointcut(asyncAnnotationTypes); } /** * Set the {@code BeanFactory} to be used when looking up executors by qualifier. */ @Override public void setBeanFactory(BeanFactory beanFactory) { if (this.advice instanceof BeanFactoryAware) { ((BeanFactoryAware) this.advice).setBeanFactory(beanFactory); } } @Override public Advice getAdvice() { return this.advice; } @Override public Pointcut getPointcut() { return this.pointcut; } //构建通知，一个简单的拦截器 protected Advice buildAdvice( @Nullable Supplier executor, @Nullable Supplier exceptionHandler) { AnnotationAsyncExecutionInterceptor interceptor = new AnnotationAsyncExecutionInterceptor(null); interceptor.configure(executor, exceptionHandler); return interceptor; } protected Pointcut buildPointcut(Set> asyncAnnotationTypes) { ComposablePointcut result = null; for (Class asyncAnnotationType : asyncAnnotationTypes) { // 根据cpc和mpc 匹配器进行匹配 //检查类上是否有@Async注解 Pointcut cpc = new AnnotationMatchingPointcut(asyncAnnotationType, true); //检查方法是是否有@Async注解。 Pointcut mpc = new AnnotationMatchingPointcut(null, asyncAnnotationType, true); if (result == null) { result = new ComposablePointcut(cpc); } else { result.union(cpc); } result = result.union(mpc); } return (result != null ? result : Pointcut.TRUE); } } ``` 再找到它的通知逻辑buildAdvice，就是一个拦截器，生成AnnotationAsyncExecutionInterceptor对象，对于Interceptor，关注它的核心方法invoke就行了。它的父类AsyncExecutionInterceptor重写了AsyncExecutionInterceptor接口的invoke方法。代码如下 ```java public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport implements MethodInterceptor, Ordered { public AsyncExecutionInterceptor(@Nullable Executor defaultExecutor) { super(defaultExecutor); } public AsyncExecutionInterceptor(@Nullable Executor defaultExecutor, AsyncUncaughtExceptionHandler exceptionHandler) { super(defaultExecutor, exceptionHandler); } @Override @Nullable // public Object invoke(final MethodInvocation invocation) throws Throwable { Class targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null); Method specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass); final Method userDeclaredMethod = BridgeMethodResolver.findBridgedMethod(specificMethod); // 获取到一个线程池 AsyncTaskExecutor executor = determineAsyncExecutor(userDeclaredMethod); if (executor == null) { throw new IllegalStateException( "No executor specified and no default executor set on AsyncExecutionInterceptor either"); } // 然后将这个方法封装成一个 Callable对象传入到线程池中执行 Callable