springboot中@Async原理简要分析

于 2024-06-27 16:55:47 发布
阅读量911 收藏 23
点赞数 14
文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hbqst/article/details/140015099
版权

通用配置

  1. 要想开启@Async支持，需要在配置类上加上@EnableAsync注解
  2. 这个配置类通常可以实现AsyncConfigurer，重写方法以自定义异步Executor和异常处理Handler
@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(7);
        executor.setMaxPoolSize(42);
        executor.setQueueCapacity(11);
        executor.setThreadNamePrefix("MyExecutor-");
        executor.initialize();
        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new SimpleAsyncUncaughtExceptionHandler();
    }
}

@EnableAsync

  1. 导入AsyncConfigurationSelector
  2. annotation属性：可以自定义异步注解，默认支持@Async和@Asynchronous
  3. mode属性：默认使用动态代理，即运行时增强
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AsyncConfigurationSelector.class)
public @interface EnableAsync {

	Class<? extends Annotation> annotation() default Annotation.class;

	boolean proxyTargetClass() default false;

	AdviceMode mode() default AdviceMode.PROXY;

	int order() default Ordered.LOWEST_PRECEDENCE;

}

AsyncConfigurationSelector

这是一个ImportSelector
AdviceModeImportSelector中重写了selectImports(AnnotationMetadata importingClassMetadata)；同时定义抽象方法selectImports(AdviceMode adviceMode);
AsyncConfigurationSelector中实现抽象方法selectImports(AdviceMode adviceMode)，这是一个典型的模板方法设计；
在这里插入图片描述

不管是那个selectImports，最终目的都是将返回值中的类对象注册到容器
这里即为ProxyAsyncConfiguration

public class AsyncConfigurationSelector extends AdviceModeImportSelector<EnableAsync> {

	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:
				return new String[] {ProxyAsyncConfiguration.class.getName()};
			case ASPECTJ:
				return new String[] {ASYNC_EXECUTION_ASPECT_CONFIGURATION_CLASS_NAME};
			default:
				return null;
		}
	}
}

ProxyAsyncConfiguration

这是一个配置类，注册了一个AsyncAnnotationBeanPostProcessor 的Bean；
在注册AsyncAnnotationBeanPostProcessor 之前，必须要确保enableAsync完成初始化（父类中进行）；
然后配置AsyncAnnotationBeanPostProcessor 对象的一些属性，其中bpp.configure(this.executor, this.exceptionHandler);中的executor和exceptionHandler，也是在父类中赋值的

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

}

这个类继承了AbstractAsyncConfiguration ，这个父类有两个作用

  1. 实现了ImportAware，意味着会在合适的时机自动调用setImportMetadata方法；这里即通过metadata获取@EnableAsync的注解信息，保存到enableAsync
  2. 导入自定义的AsyncConfigurer，设置executor和exceptionHandler，如果没有则返回null（这里先返回null，后面会有默认行为）
@Configuration(proxyBeanMethods = false)
public abstract class AbstractAsyncConfiguration implements ImportAware {

	@Nullable
	protected AnnotationAttributes enableAsync;

	@Nullable
	protected Supplier<Executor> executor;

	@Nullable
	protected Supplier<AsyncUncaughtExceptionHandler> exceptionHandler;


	@Override
	public void setImportMetadata(AnnotationMetadata importMetadata) {
		this.enableAsync = AnnotationAttributes.fromMap(
				importMetadata.getAnnotationAttributes(EnableAsync.class.getName()));
		if (this.enableAsync == null) {
			throw new IllegalArgumentException(
					"@EnableAsync is not present on importing class " + importMetadata.getClassName());
		}
	}

	/**
	 * Collect any {@link AsyncConfigurer} beans through autowiring.
	 */
	@Autowired
	void setConfigurers(ObjectProvider<AsyncConfigurer> configurers) {
		Supplier<AsyncConfigurer> configurer = SingletonSupplier.of(() -> {
			List<AsyncConfigurer> candidates = configurers.stream().collect(Collectors.toList());
			if (CollectionUtils.isEmpty(candidates)) {
				return null;
			}
			if (candidates.size() > 1) {
				throw new IllegalStateException("Only one AsyncConfigurer may exist");
			}
			return candidates.get(0);
		});
		this.executor = adapt(configurer, AsyncConfigurer::getAsyncExecutor);
		this.exceptionHandler = adapt(configurer, AsyncConfigurer::getAsyncUncaughtExceptionHandler);
	}

	private <T> Supplier<T> adapt(Supplier<AsyncConfigurer> supplier, Function<AsyncConfigurer, T> provider) {
		return () -> {
			AsyncConfigurer configurer = supplier.get();
			return (configurer != null ? provider.apply(configurer) : null);
		};
	}

}

AsyncAnnotationBeanPostProcessor

这是一个BeanPostProcessor，两个postProcess方法在AbstractAdvisingBeanPostProcessor中被实现；
另外注意到还实现了BeanFactoryAware，BeanFactoryAware的setBeanFactory回调方法是要在BeanPostProcessor的postProcess方法之前执行的，因此先关注setBeanFactory方法
在这里插入图片描述

AsyncAnnotationBeanPostProcessor重写了setBeanFactory方法
主要是创建了AsyncAnnotationAdvisor ，并赋值给advisor属性


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

AsyncAnnotationAdvisor 是一个Advisor（切面），其中定义了Advice（通知），Pointcut（切点）


public class AsyncAnnotationAdvisor extends AbstractPointcutAdvisor implements BeanFactoryAware {

	private Advice advice;

	private Pointcut pointcut;

	// ...
}

回顾一下编码实现AOP ，需要几个核心对象

  1. MethodInterceptor
  2. ProxyFactory
  3. Pointcut
  4. Advisor（Pointcut + MethodInterceptor）

这里的AsyncAnnotationAdvisor 就是对应的第4个
参考

AsyncAnnotationAdvisor

看一下AsyncAnnotationAdvisor 的构造函数，是如何创建Pointcut和Advice的;

  1. 前面添加了@Async注解支持，以及尝试添加javax.ejb.Asynchronous
  2. 接着就是重点关注的，创建advice，pointcut
public AsyncAnnotationAdvisor(
		@Nullable Supplier<Executor> executor, @Nullable Supplier<AsyncUncaughtExceptionHandler> exceptionHandler) {

	Set<Class<? extends Annotation>> asyncAnnotationTypes = new LinkedHashSet<>(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.
	}
	this.advice = buildAdvice(executor, exceptionHandler);
	this.pointcut = buildPointcut(asyncAnnotationTypes);
}

buildPointcut大概意思就是把默认的@Async注解和自定义注解都作为切点

buildAdvice中使用的是AnnotationAsyncExecutionInterceptor ，即增强方法（MethodInterceptor）；
configure方法中就是没有自定义AsyncConfigurer时，默认的executor和exceptionHandler逻辑

protected Advice buildAdvice(
		@Nullable Supplier<Executor> executor, @Nullable Supplier<AsyncUncaughtExceptionHandler> exceptionHandler) {

	AnnotationAsyncExecutionInterceptor interceptor = new AnnotationAsyncExecutionInterceptor(null);
	interceptor.configure(executor, exceptionHandler);
	return interceptor;
}

public void configure(@Nullable Supplier<Executor> defaultExecutor,
		@Nullable Supplier<AsyncUncaughtExceptionHandler> exceptionHandler) {

	this.defaultExecutor = new SingletonSupplier<>(defaultExecutor, () -> getDefaultExecutor(this.beanFactory));
	this.exceptionHandler = new SingletonSupplier<>(exceptionHandler, SimpleAsyncUncaughtExceptionHandler::new);
}

AnnotationAsyncExecutionInterceptor

增强方法invoke定义在AsyncExecutionInterceptor

在这里插入图片描述

到这逻辑就很清晰了，会将我们自己的方法包装成一个Callable，然后在doSubmit中执行；
执行过程中发生了异常，会找到exceptionHandler处理异常（如果我们自定义了的话）；
doSubmit方法中，根据不同的返回值，执行相应的逻辑，从这里也可得知，可以将方法返回值定义为：

  1. CompletableFuture
  2. ListenableFuture
  3. Future
@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<Object> task = () -> {
		try {
			Object result = invocation.proceed();
			if (result instanceof Future) {
				return ((Future<?>) result).get();
			}
		}
		catch (ExecutionException ex) {
			handleError(ex.getCause(), userDeclaredMethod, invocation.getArguments());
		}
		catch (Throwable ex) {
			handleError(ex, userDeclaredMethod, invocation.getArguments());
		}
		return null;
	};

	return doSubmit(task, executor, invocation.getMethod().getReturnType());
}


@Nullable
protected Object doSubmit(Callable<Object> task, AsyncTaskExecutor executor, Class<?> returnType) {
	if (CompletableFuture.class.isAssignableFrom(returnType)) {
		return CompletableFuture.supplyAsync(() -> {
			try {
				return task.call();
			}
			catch (Throwable ex) {
				throw new CompletionException(ex);
			}
		}, executor);
	}
	else if (ListenableFuture.class.isAssignableFrom(returnType)) {
		return ((AsyncListenableTaskExecutor) executor).submitListenable(task);
	}
	else if (Future.class.isAssignableFrom(returnType)) {
		return executor.submit(task);
	}
	else {
		executor.submit(task);
		return null;
	}
}

创建代理对象

回到AsyncAnnotationBeanPostProcessor#postProcessAfterInitialization，在这里创建了最终的代理对象；
同时可以看到ProxyFacory对象，创建代理的基本步骤类似，可参考这篇文章

@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) {
		if (this.advisor == null || bean instanceof AopInfrastructureBean) {
			// Ignore AOP infrastructure such as scoped proxies.
			return bean;
		}

		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...
				if (this.beforeExistingAdvisors) {
					advised.addAdvisor(0, this.advisor);
				}
				else {
					advised.addAdvisor(this.advisor);
				}
				return bean;
			}
		}

		if (isEligible(bean, beanName)) {
			ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);
			if (!proxyFactory.isProxyTargetClass()) {
				evaluateProxyInterfaces(bean.getClass(), proxyFactory);
			}
			proxyFactory.addAdvisor(this.advisor);
			customizeProxyFactory(proxyFactory);

			// Use original ClassLoader if bean class not locally loaded in overriding class loader
			ClassLoader classLoader = getProxyClassLoader();
			if (classLoader instanceof SmartClassLoader && classLoader != bean.getClass().getClassLoader()) {
				classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
			}
			return proxyFactory.getProxy(classLoader);
		}

		// No proxy needed.
		return bean;
	}

参考

不仅会用@Async，我把源码也梳理了一遍（中）
@Async源码实现

hbqst
关注
  • 14
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot中异步线程池AsynConfigurer配置
kimichen123的专栏
10-26 1897
什么是AsynConfigurer AsynConfigurer的与@Async注解密不可分，在这里我们先说一下什么是@Async。@Async注解的就是通过AsyncAnnotationBeanPostProcessor这个后置处理器生成一个代理对象来实现异步的。 为什么需要AsynConfigurer Spring可以通过@EnableAsync和@Async两个注解实现异步操作。启动类加上:@EnableAsync注解，同时并且在service上加上@Async...
SpringBoot项目@Async方法问题解决方案
08-19
主要介绍了SpringBoot项目@Async方法问题解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springboot中@Async异步调用注解的使用
最新发布
12-14
springboot中@Async异步调用注解的使用
springboot通过AsyncConfigurer接口实现异步线程池自动化配置组件
OceanSky的专栏
08-22 1万+
springboot提供了org.springframework.scheduling.annotation.AsyncConfigurer接口让开发人员可以自定义线程池执行器；框架默认提供了一个空的实现类AsyncConfigurerSupport，不过两个方法体内部提供的都是空实现； 1.首先看下AsyncConfigurer接口 public interface AsyncConfigurer { /** * 方法返回一个实际执行线程的线程池 */ @Nullable defaul.
SpringBoot 线程池配置 实现AsyncConfigurer接口方法
C18298182575的博客
11-14 1256
@Async 自定义线程池
Springboot Async异步处理方案
杨海吉
11-29 453
/计算计算机的核数 ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();//配置核心线程数 executor . setCorePoolSize(processors * 5);//配置最大线程数 executor . setMaxPoolSize(processors * 5);//配置队列大小 executor . setQueueCapacity(1000);
Spring Boot：Spring异步注解@Async
言尭的博客
05-06 1329
简介 应用场景 同步：同步就是整个处理过程顺序执行，当各个过程都执行完毕，并返回结果。 异步：异步调用则是只是发送了调用的指令，调用者无需等待被调用的方法完全执行完毕；而是继续执行下面的流程。 例如， 在某个调用中，需要顺序调用 A, B, C三个过程方法；如他们都是同步调用，则需要将他们都顺序执行完毕之后，方算作过程执行完毕； 如B为一个异步的调用方法，则在执行完A之后，调用B，并不等待B完成，而是执行开始调用C，待C执行完毕之后，就意味着这个过程执行完毕了。在Java中，一般在处理类似的...
springboot中@Async默认线程池导致OOM问题
08-19
SpringBoot 中 @Async 默认线程池导致 OOM 问题 在 SpringBoot 中使用 @Async 注解来实现异步操作是一种非常常见的做法，但是如果不小心，可能会导致 OOM（Out of Memory）问题。本文将详细介绍 SpringBoot 中 @...
谈谈SpringBoot中@Async注解使用的一些误区
09-19
在Spring Boot应用中，`@Async`注解是Spring框架提供的异步处理功能，它使得开发者可以方便地实现非阻塞式编程，提高应用程序的执行效率。然而，很多初学者在使用`@Async`时可能会遇到一些误区，导致程序运行结果不...
Spring Boot利用@Async如何实现异步调用：自定义线程池
08-27
在Spring Boot中，可以使用@Async注解来实现异步调用。 使用@Async实现异步调用 在Spring Boot中，使用@Async注解可以将方法异步执行。@Async注解可以应用于方法上，使得该方法可以异步执行。例如： ```java @...
SpringBoot 教程之处理异步请求——@EnableAsync@Async
weixin_38446891的博客
08-03 999
@EnableAsync 注解
【SpringBoot】@Async、AsyncConfigurer源码解析
qq_27579471的博客
08-05 2384
前言 之前写过一篇@Async、@EnableAsync、@EnableScheduler、@Scheduled在Spring应用中的基本使用的文章。 最近在学习SpringBoot的异步任务，发现书中还提及到AsyncConfigurer接口，之前没见过它啊-_-! 那么 这个AsyncConfigurer接口到底有什么用？我们的异步执行器配置类要不要实现它？ 带着疑惑，我就去阅读了一下相关的源码，终于找到答案了。 顺便还理清楚了另一个问题：Spring到底是如何决定某个目标方法使用哪个异步执行器(线程
SpringBoot 线程池配置 实现AsyncConfigurer接口
热门推荐
qq_30281443的博客
10-24 1万+
线程是开发中常用到的，但是如果没有定义线程池，程序不断的创建，销毁线程，需要消耗很多时间，所以我们定义线程池可以减小这部分时间，我来实现AsyncConfigurer来配置线程池，先看看这个接口有什么方法 public interface AsyncConfigurer { Executor getAsyncExecutor(); AsyncUncaughtExceptionHand...
通过配置AsyncConfigurer来实现springboot的@Async异步调用异常捕获
老专家的博客
08-16 1万+
@Async 注解在service上，可以实现在controller的异步调用，调用的被@Async注解的方法会在一个单独线程内运行，适合即使返回，异步解耦，service慢慢去处理 @Async 注解的方法只能 返回void或者future类型的返回值，其他值会使 注解无效，因为不能异步执行 被@Async 的方法在独立线程调用，不能被@ControllerAdvice全局异常处理器捕获，所以需...
Spring Boot 知识点
集腋成裘
04-25 275
Spring Boot 知识点 开启异步线程池 使用注解，可以更便捷的使用基于 Executor 框架的线程池。Spring Boot 框架中提供了一个 AsyncConfigurer 接口以及一个默认的 AsyncConfigurerSupport 实现。通过实现该接口，或继承该实现，可以自定义自己的线程池和异常处理操作。 @Configuration @EnableAsync public class AsyncConfig implements AsyncConfigurer { @Overri
Springboot使用@Async多线程注解
李小德不晓得的博客
11-06 8423
本文主要讲解 @Async 的基本使用及和 AsyncConfigurer 接口的关系，对于线程池的作用、线程池的参数(核心线程、最大线程......)及运行原理，这里不再过多赘述。
SpringBoot @Async注解解析
专注基础架构领域
08-08 2226
什么是异步调用？ 异步调用是相对于同步调用而言的，同步调用是指程序按预定顺序一步步执行，每一步必须等到上一步执行完后才能执行，异步调用则无需等待上一步程序执行完即可执行。   如何实现异步调用？ 多线程，这是很多人第一眼想到的关键词，没错，多线程就是一种实现异步调用的方式。   在非spring目项目中我们要实现异步调用的就是使用多线程方式，可以自己实现Runable接口或者集成Thr...
Spring Boot学习（三十二）：异步执行注解@Async
qq_36551991的博客
07-26 4835
目录前言1、开启异步异步调用2、定义异步任务常见TaskExecutor3、自定义Async配置 前言 当我们需要异步执行某个方法时，最常用的方法就是新建一个线程去执行任务或者把任务提交到线程池异步执行。在spring boot，最简单的方式就是使用 @Async注解。下面我们就来体验下 @Async注解 1、开启异步异步调用 在启动类添加@EnableAsync注解即可开启异步调用 @SpringBootApplication @MapperScan("com.example.testdemo.mappe
Springboot的@Async异步
09-09
@Async是Spring框架中的一个注解，用于标记一个方法为异步方法。当一个方法被@Async注解修饰后，该方法将在调用时立即返回，不会阻塞主线程的执行。相反，该方法将在一个单独的线程中异步执行。 使用@Async注解需要满足以下条件： 1. 在Spring Boot项目中，需要在配置类上添加@EnableAsync注解以启用异步方法的支持。 2. 在异步方法上使用@Async注解，标记该方法为异步方法。 3. 异步方法必须返回void或者Future<T>类型，其中T代表异步方法的返回值类型。 4. 调用异步方法时，使用Spring容器中的代理对象进行调用，以确保异步方法生效。 以下是一个使用@Async注解的示例： ```java @Service public class MyService { @Async public void asyncMethod() { // 异步执行的逻辑代码 } } ``` 在上面的示例中，asyncMethod()方法被@Async注解修饰，表示该方法为异步方法。当调用asyncMethod()时，该方法将在一个单独的线程中异步执行。 需要注意的是，@Async注解默认使用一个名为"taskExecutor"的线程池来执行异步方法。如果不指定其他的线程池，Spring将使用默认的线程池配置。你可以通过在配置类中定义一个名为"taskExecutor"的线程池来自定义线程池的配置，例如线程池大小、队列容量等。 希望以上信息能够帮助到你，如果还有其他问题，请继续提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值