一.前言

在整理老的业务逻辑代码时候发现好多接口实现上面都标记了 @Async注解。我本身对这个注解使用的比较少，异步逻辑我都习惯自定义ThreadPoolExecutor工具类。正好借着这次梳理代码结构，来看看 @Async这个注解到底在玩什么？

本文将会给大家从 @Async注解使用层面入手逐步解读源码，分析各种踩坑实践，并且扩展sleuth链路追踪与线程变量如何花式应用。

二.尝鲜使用

Spring中，被 @Async注解标注的方法，称之为异步方法。这些方法将在执行的时候，将会在独立的线程中被执行，调用者无需等待它的完成，即可继续其他的操作，是spring默认提供的异步调用方式。

2.1.使用方式

使用 @Async进行异步变成的方式特别简单。

1. 在启动类或者能被启动类扫描到的配置类上标注@EnableAsync
2. 在被spring管理的bean的方法上标注@Async()
3. 调用方法与被调用方法不在同一个bean中。

仔细品味一下上面三个限制条件，任意一个不满足，均会导致 @Async无法生效。

2.2.最简单的demo演示

启动类定义

@SpringBootApplication
@EnableAsync
public class DemoApplication {
​
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
​
}
复制代码

controller层方法定义

@RestController
@RequestMapping
public class TestController {
​
    @Autowired
    TestService testService;
​
    @GetMapping()
    public void test(){
        for (int i = 0; i <5 ; i++) {
            testService.testAsync();
        }
    }
}
复制代码

service方法定义

@Service
@Slf4j
public class TestServiceImpl implements TestService {
​
    @Override
    @Async
    public void testAsync(){
        log.info("嘻嘻");
    }
}
复制代码

日志输出

- 2021-09-15 19:39:54.300,[http-nio-8088-exec-5], com.examp.controller.TestController - 嘿嘿
- 2021-09-15 19:36:54.302,[task-5], com.examp.service.impl.TestServiceImpl - 嘻嘻
- 2021-09-15 19:36:54.302,[task-4], com.examp.service.impl.TestServiceImpl - 嘻嘻
- 2021-09-15 19:36:54.302,[task-1], com.examp.service.impl.TestServiceImpl - 嘻嘻
- 2021-09-15 19:36:54.302,[task-2], com.examp.service.impl.TestServiceImpl - 嘻嘻
- 2021-09-15 19:36:54.302,[task-3], com.examp.service.impl.TestServiceImpl - 嘻嘻
复制代码

从日志打印可以发现，controller方法打印与service层方法打印日志使用的是不同的线程。

使用是真滴简单！

2.3.踩坑提问

前面两点可以看到我们使用@Async进行异步变成是真的简单，但是里面也埋伏了各种各样的坑点。

先抛出问题，大家可以先思考：

1. 为什么阿里不推荐直接使用@Async
2. @Async标注的方法是否事务一致
3. 同一个类里面A->B，B方法上标注了@Async，为了调用成功，在类中注入当前类方式能否异步调用成功
4. @Async标注的方法能否读取到ThreadLocal的变量
5. @Async标注的方法能否获取返回值
6. slueth链路追踪的traceId能否追踪到线程池内、

三.源码分析

废话不多说，看看源码。

3.1.@Async

/**
* 该注解可以标记一个异步执行的方法，也可以用来标注类，表示类中的所有方法都是异步执行的。
* 入参随意，但返回值只能是void或者Future.(ListenableFuture接口/CompletableFuture类)
* Future是代理返回的切实的异步返回，用以追踪异步方法的返回值。当然也可以使用AsyncResult类（实现
* ListenableFuture接口）(Spring或者EJB都有)或者CompletableFuture类
*/
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Async {
​
   //用以限定执行方法的执行器名称（自定义）：Executor或者TaskExecutor
   //加在类上表示整个类都使用，加在方法上会覆盖类上的设置
   String value() default "";
​
}
复制代码

3.2.@EnableAsync

/**
* 开启spring异步执行器，类似xml中的task标签配置，需要联合@Configuration注解一起使用,对应文章开头，注解需* 要标注在启动类或者能被启动类扫描到的配置类上。
*
* 默认情况下spring会先搜索TaskExecutor类型的bean或者名字为taskExecutor的Executor类型的bean,都不存在使* 用SimpleAsyncTaskExecutor执行器
*
* 可实现AsyncConfigurer接口复写getAsyncExecutor获取异步执行器，getAsyncUncaughtExceptionHandler获* 取异步未捕获异常处理器
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AsyncConfigurationSelector.class)
public @interface EnableAsync {
​
   // 该属性用来支持用户自定义异步注解，默认扫描spring的@Async和EJB3.1的@code @javax.ejb.Asynchronous
   Class annotation() default Annotation.class;
​
   //标明是否需要创建CGLIB子类代理，AdviceMode=PROXY时才适用。注意设置为true时，其它spring管理的bean也会升级到CGLIB子类代理
   boolean proxyTargetClass() default false;
​
   //标明异步通知将会如何实现，默认PROXY，如需支持同一个类中非异步方法调用另一个异步方法，需要设置为ASPECTJ
   AdviceMode mode() default AdviceMode.PROXY;
​
   //标明异步注解bean处理器应该遵循的执行顺序，默认最低的优先级（Integer.MAX_VALUE，值越小优先级越高）
   int order() default Ordered.LOWEST_PRECEDENCE;
​
}
复制代码

3.3.AsyncConfigurationSelector

@EnableAsync注解是非常明显的一个启动注解，几乎所有spring的开启配置类的注解都是以@Enable开头的。方法里面一看也是熟悉的老朋友 @Import

//查询器：基于@EanableAsync中定义的模式AdviceMode加在@Configuration标记的类上，确定抽象异步配置类的实现
public class AsyncConfigurationSelector extends AdviceModeImportSelector {
​
   private static final String ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME =
         "org.springframework.scheduling.aspectj.AspectJAsyncConfiguration";
​
​
   //根据当前注解标注的方法坐在类的代理方式决定代理模式
   @Override
   @Nullable
   public String[] selectImports(AdviceMode adviceMode) {
      switch (adviceMode) {
         case PROXY://jdk接口代理
            return new String[] {ProxyAsyncConfiguration.class.getName()};
         case ASPECTJ://cglib代理
            return new String[] {ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME};
         default:
            return null;
      }
   }
​
}
复制代码

类还是比较简单的，就是决定使用什么代理模式

3.4.ProxyAsyncConfiguration

以jdk接口代理为例，瞅一瞅看看

@Configuration
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
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");
      //新建一个异步注解bean后处理器
      AsyncAnnotationBeanPostProcessor bpp = new AsyncAnnotationBeanPostProcessor();
      //配置执行器与异常处理器
      bpp.configure(this.executor, this.exceptionHandler);
      Class customAsyncAnnotation = this.enableAsync.getClass("annotation");
      if (customAsyncAnnotation != AnnotationUtils.getDefaultValue(EnableAsync.class, "annotation")) {
         bpp.setAsyncAnnotationType(customAsyncAnnotation);
      }
     //设置是否升级到CGLIB子类代理，默认不开启
      bpp.setProxyTargetClass(this.enableAsync.getBoolean("proxyTargetClass"));
      //设置执行优先级，默认最后执行
      bpp.setOrder(this.enableAsync.getNumber("order"));
      return bpp;
   }
​
}
复制代码

配置类操作也比较清晰，就是集成AbstractAsyncConfiguration抽象类，新建AsyncAnnotationBeanPostProcessor后置处理器并进行参数初始化。

3.5.AbstractAsyncConfiguration

@Configuration
public abstract class AbstractAsyncConfiguration implements ImportAware {
  
  //enableAsync注解属性
   @Nullable
   protected AnnotationAttributes 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());
      }
   }
​
   //根据配置设置异步任务执行器和异常处理器
   @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;
   }
​
}
复制代码

3.6.AsyncAnnotationBeanPostProcessor

由依赖图可知，这是一个bean的后置处理器

public class AsyncAnnotationBeanPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessor {
​
   //省略部分代码
  
  //初始化异步处理切面
   @Override
   public void setBeanFactory(BeanFactory beanFactory) {
      super.setBeanFactory(beanFactory);
      
      //初始化切面
      AsyncAnnotationAdvisor advisor = new AsyncAnnotationAdvisor(this.executor, this.exceptionHandler);
      if (this.asyncAnnotationType != null) {
         advisor.setAsyncAnnotationType(this.asyncAnnotationType);
      }
      advisor.setBeanFactory(beanFactory);
      this.advisor = advisor;
   }
​
}
复制代码

3.7.AsyncAnnotationAdvisor

芜湖，发现了，这是一个异步注解的切面，定义了@Async解析的解析的切面，具体处理在AbstractAdvisingBeanPostProcessor.postProcessAfterInitialization方法

3.8.Interceptor切面执行

Interceptor接口的invoke方法，

断点打在接口方法处，逐步下去，找到AsyncExecutionInterceptor类

@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