Spring @Async：Aysnc的异步执行的线程池实现原理

对于异步方法调用，从Spring3开始提供了@Async注解，该注解可以被标注在方法上，以便异步地调用该方法。调用者将在调用时立即返回，方法的实际执行将提交给Spring TaskExecutor的任务中，由指定的线程池中的线程执行。

遇到开发人员只会简单的使用@Async注解，而不知其实现原理，更糟糕的是有时会错误的使用。本篇将深入源码分析@Async注解背后的实现原理，避免错误使用。

@Async

以下是@Async注解的源码，从源码中看到它可以被标注在类或方法上，用于实现方法的异步执行。当被标注在类上时，表明类中的所有方法都被指定的异步执行器执行，如果方法上也有该注解，将覆盖类上的注解内容。

/**
 * 该注释将方法标记为异步执行，也可以在类级别上使用，在这种情况下，类的所有方法都被认为是异步的。
 * 就目标方法签名而言，任何参数类型都是支持。但是，返回类型被约束为void或java.util.concurrent.Furture。
 * 在后一种情况下，您可以声明它们更具体org.springframework.util.concurrent.ListenableFuture或者java.util.concurrent.CompletableFuture类型，
 * 它允许与异步任务进行更丰富的交互，并允许通过进一步的处理步骤直接组合。
 * 从代理返回的Future句柄将是一个实际的异步Future，可用于跟踪异步方法执行的结果。然而，由于目标方法需要实现相同的签名，它将不得不返回一个临时的Future句柄，
 * 它只是通过传递一个值:例如Spring的AsyncResult, EJB 3.1的javax.ejb。AsyncResult或java.util.concurrent.CompletableFuture.completedFuture(对象)。
 *
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Async {

    /**
     * 指定异步操作的限定符值。
     * 可以用来确定在执行此方法时要使用的目标执行器，匹配特定执行器或TaskExecutorbean定义的限定符值(或bean名)。
     * 当在类级别指定@Async注释时，表示给定的执行器应该用于类中的所有方法。方法级别对async# value的使用总是覆盖在类级别设置的任何值。
     * @return
     */
    String value() default "";

}

实现原理

为了更基础的分析异步调用背后的实现原理，这里选择使用xml配置文件的方式。使用xml配置文件方式时，一般会配置如下元素：

<task:annotation-driven executor="myExecutor" exception-handler="exceptionHandler"/>
<task:executor id="myExecutor" pool-size="5"/>
<bean id="exceptionHandler" class="com.abc.MyAsynExceptionHandler"/>

下文将围绕这三个配置进行深入分析。

这里就从task标签解析开始。一般对于这种标签的解析都会有相应的NamespaceHandler，根据Spring命名的套路查找TaskNamespaceHandler类，具体代码如下：

/**
 * {@code NamespaceHandler} for the 'task' namespace.
 *
 * @author Mark Fisher
 * @since 3.0
 */
public class TaskNamespaceHandler extends NamespaceHandlerSupport {

    @Override
    public void init() {
        this.registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
        this.registerBeanDefinitionParser("executor", new ExecutorBeanDefinitionParser());
        this.registerBeanDefinitionParser("scheduled-tasks", new ScheduledTasksBeanDefinitionParser());
        this.registerBeanDefinitionParser("scheduler", new SchedulerBeanDefinitionParser());
    }

}

通过TaskNamespaceHandler可知Task标签下annotation-driven和executor元素的处理类分别是AnnotationDrivenBeanDefinitionParser和ExecutorBeanDefinitionParser，先分析一下executor元素，其对应的处理类是ExecutorBeanDefinitionParser，下图是这个类的继承关系图：

 这个类用于解析和定义单个BeanDefinition，

@Override
    protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
        String keepAliveSeconds = element.getAttribute("keep-alive");
        if (StringUtils.hasText(keepAliveSeconds)) {
            builder.addPropertyValue("keepAliveSeconds", keepAliveSeconds);
        }
        String queueCapacity = element.getAttribute("queue-capacity");
        if (StringUtils.hasText(queueCapacity)) {
            builder.addPropertyValue("queueCapacity", queueCapacity);
        }
        configureRejectionPolicy(element, builder);
        String poolSize = element.getAttribute("pool-size");
        if (StringUtils.hasText(poolSize)) {
            builder.addPropertyValue("poolSize", poolSize);
        }
    }

从parse方法追踪具体的实现逻辑，发现这个类主要是根据executor元素中的配置，例如pool-size创建一个TaskExecutorFactoryBean对象，

ExecutorBeanDefinitionParser中对拒绝策略的加载：

private void configureRejectionPolicy(Element element, BeanDefinitionBuilder builder) {
        String rejectionPolicy = element.getAttribute("rejection-policy");
        if (!StringUtils.hasText(rejectionPolicy)) {
            return;
        }
        String prefix = "java.util.concurrent.ThreadPoolExecutor.";
        String policyClassName;
        if (rejectionPolicy.equals("ABORT")) {
            policyClassName = prefix + "AbortPolicy";
        }
        else if (rejectionPolicy.equals("CALLER_RUNS")) {
            policyClassName = prefix + "CallerRunsPolicy";
        }
        else if (rejectionPolicy.equals("DISCARD")) {
            policyClassName = prefix + "DiscardPolicy";
        }
        else if (rejectionPolicy.equals("DISCARD_OLDEST")) {
            policyClassName = prefix + "DiscardOldestPolicy";
        }
        else {
            policyClassName = rejectionPolicy;
        }
        builder.addPropertyValue("rejectedExecutionHandler", new RootBeanDefinition(policyClassName));
    }

ExecutorBeanDefinitionParser中getBeanClassName方法，可知通过TaskExecutorFactoryBean创建bean，而在TaskExecutorFactoryBean中间接使用ThreadPoolExecutor创建了一个线程池，这个线程池会在annotation-driven元素解析类中用到。 

@Override
    protected String getBeanClassName(Element element) {
        return "org.springframework.scheduling.config.TaskExecutorFactoryBean";
    }

接着分析annotation-driven元素处理类AnnotationDrivenBeanDefinitionParser，其实现了BeanDefinitionParser，关系图如下：

 这个类的parse方法体内容比较多，这个只关注重点代码，具体代码如下：

@Override
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        Object source = parserContext.extractSource(element);

        // Register component for the surrounding <task:annotation-driven> element.
        CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), source);
        parserContext.pushContainingComponent(compDefinition);

        // Nest the concrete post-processor bean in the surrounding component.
        BeanDefinitionRegistry registry = parserContext.getRegistry();

        String mode = element.getAttribute("mode");
        if ("aspectj".equals(mode)) {
            // mode="aspectj"
            registerAsyncExecutionAspect(element, parserContext);
        }
        else {
            // mode="proxy"
            if (registry.containsBeanDefinition(TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME)) {
                parserContext.getReaderContext().error(
                        "Only one AsyncAnnotationBeanPostProcessor may exist within the context.", source);
            }
            else {
                BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(
                        "org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor");
                builder.getRawBeanDefinition().setSource(source);
                //xml中的executor
                String executor = element.getAttribute("executor");
                if (StringUtils.hasText(executor)) {
                    builder.addPropertyReference("executor", executor);
                }
                   
                //xml中的exception-handler节点
                String exceptionHandler = element.getAttribute("exception-handler");
                if (StringUtils.hasText(exceptionHandler)) {
                    builder.addPropertyReference("exceptionHandler", exceptionHandler);
                }
                if (Boolean.valueOf(element.getAttribute(AopNamespaceUtils.PROXY_TARGET_CLASS_ATTRIBUTE))) {
                    builder.addPropertyValue("proxyTargetClass", true);
                }
                registerPostProcessor(parserContext, builder, TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME);
            }
        }

        if (registry.containsBeanDefinition(TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            parserContext.getReaderContext().error(
                    "Only one ScheduledAnnotationBeanPostProcessor may exist within the context.", source);
        }
        else {
            BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(
                    "org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor");
            builder.getRawBeanDefinition().setSource(source);
            String scheduler = element.getAttribute("scheduler");
            if (StringUtils.hasText(scheduler)) {
                builder.addPropertyReference("scheduler", scheduler);
            }
            registerPostProcessor(parserContext, builder, TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME);
        }

        // Finally register the composite component.
        parserContext.popAndRegisterContainingComponent();

        return null;
    }

默认情况下，如果没有配置mode属性，其值默认是proxy，继续执行会创建一个AsyncAnnotationBeanPostProcessor，然后解析executor属性值和exception-handler属性值并将其设置到AsyncAnnotationBeanPostProcessor中。

AsyncAnnotationBeanPostProcessor类关系图如下所示：

从图中可以看到，AsyncAnnotationBeanPostProcessor间接实现了BeanFactoryAware接口，所以它在被实例化的时候会执行setBeanFactory方法，查看这个方法的源码如下：

@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;
    }

重点关注红框中的代码，这里使用上面提到的executor元素解析得到的线程池和异常处理创建通知，使用@Async注解创建切入点，具体代码如下： 

@SuppressWarnings("unchecked")
    public AsyncAnnotationAdvisor(Executor executor, AsyncUncaughtExceptionHandler exceptionHandler) {
        Set<Class<? extends Annotation>> asyncAnnotationTypes = new LinkedHashSet<Class<? extends Annotation>>(2);
        asyncAnnotationTypes.add(Async.class);
        try {
            asyncAnnotationTypes.add((Class<? extends Annotation>)
                    ClassUtils.forName("javax.ejb.Asynchronous", AsyncAnnotationAdvisor.class.getClassLoader()));
        }
        catch (ClassNotFoundException ex) {
            // If EJB 3.1 API not present, simply ignore.
        }
        if (exceptionHandler != null) {
            this.exceptionHandler = exceptionHandler;
        }
        else {
            this.exceptionHandler = new SimpleAsyncUncaughtExceptionHandler();
        }
        //根据executor和异常处理构建AOP的通知
        this.advice = buildAdvice(executor, this.exceptionHandler);
        //根据@Async注解位置构建AOP切入点
        this.pointcut = buildPointcut(asyncAnnotationTypes);
    }

进入构建通知的方法buildAdvice， 

protected Advice buildAdvice(Executor executor, AsyncUncaughtExceptionHandler exceptionHandler) {
        return new AnnotationAsyncExecutionInterceptor(executor, exceptionHandler);
    }

查看AnnotationAsyncExecutionInterceptor源码，可以发现它继承和实现接口关系图如下：

 可以看到AnnotationAsyncExecutionInterceptor间接实现了MethodInterceptor接口，而MethodInterceptor是AOP中切入点的处理器，处理器中最终被调用的是invoke方法，下面是invoke方法的源码：

 doSubmit方法源码如下，可以看到真正执行的地方是提交给线程池执行的，实现了异步执行。

 上面的分析得到了@Async注解的切入点、切入点的处理器，必然会根据切入点创建代理，才能最终执行到MethodInterceptor的invoke方法，实现异步执行。继续分析，AsyncAnnotationBeanPostProcessor类间接实现了BeanPostProcessor接口，也就是说在bean初始化之前和之后会分别执行postProcessBeforeInitialization方法和postProcessAfterInitialization方法，而AsyncAnnotationBeanPostProcessor类的这两个方法是从AbstractAdvisingBeanPostProcessor类中继承来的，这里重点分析postProcessAfterInitialization方法，具体代码如下：

创建代理可以使用Cglib或JDK动态代理，具体代码如下：

这里选择JdkDynamicAopProxy深入分析，代理的创建这里就不深入分析了，这里重点关注一下调用代理时真正执行的invoke方法，方法体内容比较多，这里看一下如下重要代码：

public Object proceed() throws Throwable {
        //    We start with an index of -1 and increment early.
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();
        }

        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            // Evaluate dynamic method matcher here: static part will already have
            // been evaluated and found to match.
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                return dm.interceptor.invoke(this);
            }
            else {
                // Dynamic matching failed.
                // Skip this interceptor and invoke the next in the chain.
                return proceed();
            }
        }
        else {
            // It's an interceptor, so we just invoke it: The pointcut will have
            // been evaluated statically before this object was constructed.
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }

ProxyAsyncConfiguration.java源码： 

@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");
        AsyncAnnotationBeanPostProcessor bpp = new AsyncAnnotationBeanPostProcessor();
        Class<? extends Annotation> customAsyncAnnotation = this.enableAsync.getClass("annotation");
        if (customAsyncAnnotation != AnnotationUtils.getDefaultValue(EnableAsync.class, "annotation")) {
            bpp.setAsyncAnnotationType(customAsyncAnnotation);
        }
        if (this.executor != null) {
            bpp.setExecutor(this.executor);
        }
        if (this.exceptionHandler != null) {
            bpp.setExceptionHandler(this.exceptionHandler);
        }
        bpp.setProxyTargetClass(this.enableAsync.getBoolean("proxyTargetClass"));
        bpp.setOrder(this.enableAsync.<Integer>getNumber("order"));
        return bpp;
    }

}

 AbstractAsyncConfiguration.java源码：

@Autowired(required = false)
    void setConfigurers(Collection<AsyncConfigurer> 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();
    }

看AsyncDefaultAutoConfiguration.java源码： 

public class AsyncDefaultAutoConfiguration {

    @Autowired private BeanFactory beanFactory;

    @Configuration
    @ConditionalOnMissingBean(AsyncConfigurer.class)
    @ConditionalOnProperty(value = "spring.sleuth.async.configurer.enabled", matchIfMissing = true)
    static class DefaultAsyncConfigurerSupport extends AsyncConfigurerSupport {

        @Autowired private BeanFactory beanFactory;

        @Override
        public Executor getAsyncExecutor() {
            return new LazyTraceExecutor(this.beanFactory, new SimpleAsyncTaskExecutor());
        }
    }

总结

Spring容器启动初始化bean时，判断类中是否使用了@Async注解，创建切入点和切入点处理器，根据切入点创建代理，在调用@Async注解标注的方法时，会调用代理，执行切入点处理器invoke方法，将方法的执行提交给线程池，实现异步执行。

所以，需要注意的一个错误用法是，如果A类的a方法(没有标注@Async)调用它自己的b方法(标注@Async)是不会异步执行的，因为从a方法进入调用的都是它本身，不会进入代理。