对于异步方法调用,从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方法进入调用的都是它本身,不会进入代理。