Spring Boot源码简析 @EnableAsync

已于 2022-02-23 21:03:47 修改
阅读量998 收藏 2
点赞数
分类专栏： Spring Boot 文章标签： spring boot
于 2022-01-28 19:15:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xing_hung/article/details/122735335
版权

相关阅读

源码

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AsyncConfigurationSelector.class)
public @interface EnableAsync {

    // 自定义类/方法上的开启异步功能的注解类型
    // 默认支持@Async/@javax.ejb.Asynchronous，自定义后则不支持默认
    Class<? extends Annotation> annotation() default Annotation.class;

    // interface-based(false) or subclass-based(true)
    boolean proxyTargetClass() default false;

    // 代理模式，支持PROXY/ASPECTJ
    AdviceMode mode() default AdviceMode.PROXY;

    int order() default Ordered.LOWEST_PRECEDENCE;
}

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Async {

    // 指定执行器，写入执行器BeanName即可采用指定执行器去异步执行方法
    String value() default "";
}

配置

配合@Configuration使用，表示开启注解驱动的异步处理；

@Configuration
@EnableAsync
public class AppConfig {
}

默认地，Spring会搜索一个执行器实例用于实现异步执行方法，从以下类型中选择一个：

  1. 唯一的org.springframework.core.task.TaskExecutor实例；
  2. 名为"taskExecutor"的java.util.concurrent.Executor实例；
    如果以上两个都不存在，则提供一个org.springframework.core.task.SimpleAsyncTaskExecutor实例处理异步方法调用；
    用户可以实现接口org.springframework.scheduling.annotation.AsyncConfigurer来提供自定义java.util.concurrent.Executor和org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler实现；
@Configuration
@EnableAsync
public class AppConfig 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 MyAsyncUncaughtExceptionHandler();
    }
}

如果只想自定义java.util.concurrent.Executor或者org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler，其它方法可以直接返回null，从而保持默认配置，此时可以考虑继承org.springframework.scheduling.annotation.AsyncConfigurerSupport；

也可以定义多个执行器，在需要异步执行的方法上通过@Async注解value属性指定具体执行器的BeanName；

@Configuration
@EnableAsync
public class AsyncConfig {

    // 自定义执行器
    @Bean(name = "myExecutor")
    public Executor myExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(4);
        executor.setMaxPoolSize(8);
        executor.setQueueCapacity(100);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("EXECUTOR");
        executor.initialize();
        return executor;
    }
}

public class Demo {

    // 指定具体执行器
    @Async(value = "myExecutor")
    public void method() {
        // do something
    }
}

简析

@EnableAsync注解通过Import机制引入AsyncConfigurationSelector；

@Import(AsyncConfigurationSelector.class)

AsyncConfigurationSelector继承自AdviceModeImportSelector，AdviceModeImportSelector实现支持AdviceMode算法模板，且支持通用的@EnableXxx注解模式，代码如下：

public final String[] selectImports(AnnotationMetadata importingClassMetadata) {
    // 获取本类支持的注解类型
    // 对于AsyncConfigurationSelector来说为EnableAsync
    Class<?> annType = GenericTypeResolver.resolveTypeArgument(getClass(), AdviceModeImportSelector.class);
    Assert.state(annType != null, "Unresolvable type argument for AdviceModeImportSelector");

    // 获取注解属性数据
    AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
    if (attributes == null) {
        throw new IllegalArgumentException(String.format(
            "@%s is not present on importing class '%s' as expected",
            annType.getSimpleName(), importingClassMetadata.getClassName()));
    }

    // 获取注解的AdviceMode属性值
    AdviceMode adviceMode = attributes.getEnum(this.getAdviceModeAttributeName());
    // 根据AdviceMode获取引入配置类信息
    // 该方法由子类实现算法细节
    String[] imports = selectImports(adviceMode);
    if (imports == null) {
        throw new IllegalArgumentException(String.format("Unknown AdviceMode: '%s'", adviceMode));
    }
    return imports;
}

@Nullable
protected abstract String[] selectImports(AdviceMode adviceMode);

AsyncConfigurationSelector实现了算法细节selectImports，代码如下：

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

@EnableAsync的mode属性默认AdviceMode.PROXY，即引入了ProxyAsyncConfiguration；
ProxyAsyncConfiguration继承自AbstractAsyncConfiguration，是一个配置类，其父类AbstractAsyncConfiguration实现了接口ImportAware，会注入@EnableAsync注解属性数据，且通过@Autowired注解注入AsyncConfigurer信息，代码如下：

public void setImportMetadata(AnnotationMetadata importMetadata) {
    // 注入@EnableAsync注解的属性数据
    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<AsyncConfigurer> configurers) {
    if (CollectionUtils.isEmpty(configurers)) {
        return;
    }
    // AsyncConfigurer bean只能存在一个
    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();
}

ProxyAsyncConfiguration配置AsyncAnnotationBeanPostProcessor Bean，代码如下：

@Bean(name = TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public AsyncAnnotationBeanPostProcessor asyncAdvisor() {
    // 校验@EnableAsync注解属性数据
    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;
}

AsyncAnnotationBeanPostProcessor

@EnableAsync注解最终引入了Bean后置处理器AsyncAnnotationBeanPostProcessor，毫无疑问，它会处理带有引发异步处理的注解（如：@Async）的Bean；
在AsyncAnnotationBeanPostProcessor的继承层次中，AbstractAdvisingBeanPostProcessor实现了通用的Bean后置处理，代码如下：

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

    // 判断Bean是否已经被代理
    if (bean instanceof Advised) {
        // 已经被代理，则无需为其创建代理，直接添加Advisor
        Advised advised = (Advised) bean;
        // 判断当前Bean是否冻结，且合格
        if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {
            // 满足要求后，则添加Advisor，即AsyncAnnotationAdvisor
            // 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;
        }
    }

    // 判断Bean是否合格
    if (isEligible(bean, beanName)) {
        // 合格则代理该Bean
        ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);
        if (!proxyFactory.isProxyTargetClass()) {
            evaluateProxyInterfaces(bean.getClass(), proxyFactory);
        }
        // 应用Advisor
        proxyFactory.addAdvisor(this.advisor);
        customizeProxyFactory(proxyFactory);
        return proxyFactory.getProxy(getProxyClassLoader());
    }

    // No async proxy needed.
    return bean;
}

protected boolean isEligible(Object bean, String beanName) {
    return isEligible(bean.getClass());
}

protected boolean isEligible(Class<?> targetClass) {
    // 如果有缓存的结果，则直接使用
    Boolean eligible = this.eligibleBeans.get(targetClass);
    if (eligible != null) {
        return eligible;
    }
    // 如果当前不存在Advisor则无需代理
    if (this.advisor == null) {
        return false;
    }
    // 当前的Advisor是否可以切入该targetClass
    eligible = AopUtils.canApply(this.advisor, targetClass);
    // 缓存结果，方便下次直接使用
    this.eligibleBeans.put(targetClass, eligible);
    return eligible;
}

AsyncAnnotationBeanPostProcessor会根据开启异步功能的注解类型、异步执行器、异常处理器生成切面AsyncAnnotationAdvisor，代码如下：

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

AsyncAnnotationAdvisor是一个PointcutAdvisor，且持有的Pointcut为聚合了AnnotationMatchingPointcut的ComposablePointcut，由此看出该切面用于处理注解；

public AsyncAnnotationAdvisor(@Nullable Executor executor, @Nullable AsyncUncaughtExceptionHandler exceptionHandler) {
    // 默认支持Async和javax.ejb.Asynchronous，故size为2
    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.
    }
    if (exceptionHandler != null) {
        // 设置自定义异常处理器，若存在的话
        this.exceptionHandler = exceptionHandler;
    }
    else {
        // 使用默认异常处理器SimpleAsyncUncaughtExceptionHandler
        this.exceptionHandler = new SimpleAsyncUncaughtExceptionHandler();
    }
    // 根据异步执行器和异常处理器生成Advice
    this.advice = buildAdvice(executor, this.exceptionHandler);
    // 生成Pointcut
    this.pointcut = buildPointcut(asyncAnnotationTypes);
}

public void setAsyncAnnotationType(Class<? extends Annotation> asyncAnnotationType) {
    Assert.notNull(asyncAnnotationType, "'asyncAnnotationType' must not be null");
    Set<Class<? extends Annotation>> asyncAnnotationTypes = new HashSet<>();
    asyncAnnotationTypes.add(asyncAnnotationType);
    // 重新生成Pointcut
    this.pointcut = buildPointcut(asyncAnnotationTypes);
}

protected Advice buildAdvice(@Nullable Executor executor, AsyncUncaughtExceptionHandler exceptionHandler) {
    // 使用AnnotationAsyncExecutionInterceptor
    return new AnnotationAsyncExecutionInterceptor(executor, exceptionHandler);
}

protected Pointcut buildPointcut(Set<Class<? extends Annotation>> asyncAnnotationTypes) {
    ComposablePointcut result = null;
    // 遍历注解类型集合，得到一个ComposablePointcut
    for (Class<? extends Annotation> asyncAnnotationType : asyncAnnotationTypes) {
        // 匹配类，忽略方法（MethodMatcher.TRUE）
        Pointcut cpc = new AnnotationMatchingPointcut(asyncAnnotationType, true);
        // 匹配方法，忽略类（ClassFilter.TRUE）
        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);
}

至此可知，AsyncAnnotationBeanPostProcessor通过组合AnnotationMatchingPointcut的ComposablePointcut判断是否可以将AsyncAnnotationAdvisor切入到Bean中，然后通过AnnotationAsyncExecutionInterceptor进行增强处理；

AnnotationAsyncExecutionInterceptor

AnnotationAsyncExecutionInterceptor继承自AsyncExecutionAspectSupport，且实现了MethodInterceptor；
AsyncExecutionAspectSupport实现了异步执行器的处理，代码如下：

protected AsyncTaskExecutor determineAsyncExecutor(Method method) {
    // 从缓存的信息中找到该Method对应的异步执行器
    AsyncTaskExecutor executor = this.executors.get(method);
    if (executor == null) {
        // 若未缓存，则需要解析对应的执行器
        Executor targetExecutor;
        // 获取执行器的合格者描述，若存在的话
        // 即@Async注解的value属性值
        String qualifier = getExecutorQualifier(method);
        if (StringUtils.hasLength(qualifier)) {
            // 若存在，则根据qualifier查找执行器
            targetExecutor = findQualifiedExecutor(this.beanFactory, qualifier);
        }
        else {
            // 不存在，则使用自定义的执行器
            targetExecutor = this.defaultExecutor;
            if (targetExecutor == null) {
                synchronized (this.executors) {
                    if (this.defaultExecutor == null) {
                        // 无自定义的执行器，则获取默认的执行器
                        this.defaultExecutor = getDefaultExecutor(this.beanFactory);
                    }
                    targetExecutor = this.defaultExecutor;
                }
            }
        }
        if (targetExecutor == null) {
            // 若还找不到执行器，则直接返回null
            return null;
        }
        // 包装targetExecutor为异步执行器
        executor = (targetExecutor instanceof AsyncListenableTaskExecutor ?
            (AsyncListenableTaskExecutor) targetExecutor : new TaskExecutorAdapter(targetExecutor));
        // 缓存该Method的异步执行器信息，方便下次直接从缓存中获取
        this.executors.put(method, executor);
    }
    return executor;
}

protected Executor findQualifiedExecutor(@Nullable BeanFactory beanFactory, String qualifier) {
    if (beanFactory == null) {
        throw new IllegalStateException("BeanFactory must be set on " + getClass().getSimpleName() +
                " to access qualified executor '" + qualifier + "'");
    }
    // 从BeanFactory中根据指定名称qualifier查找Executor类型Bean
    return BeanFactoryAnnotationUtils.qualifiedBeanOfType(beanFactory, Executor.class, qualifier);
}

protected Executor getDefaultExecutor(@Nullable BeanFactory beanFactory) {
    if (beanFactory != null) {
        try {
            // 先从BeanFactory中查找唯一的TaskExecutor类型Bean
            // Search for TaskExecutor bean... not plain Executor since that would
            // match with ScheduledExecutorService as well, which is unusable for
            // our purposes here. TaskExecutor is more clearly designed for it.
            return beanFactory.getBean(TaskExecutor.class);
        }
        catch (NoUniqueBeanDefinitionException ex) {
            logger.debug("Could not find unique TaskExecutor bean", ex);
            try {
                // 若存在多个，则继续根据名称"taskExecutor"查找Executor类型Bean
                return beanFactory.getBean(DEFAULT_TASK_EXECUTOR_BEAN_NAME, Executor.class);
            }
            catch (NoSuchBeanDefinitionException ex2) {
                if (logger.isInfoEnabled()) {
                    logger.info("More than one TaskExecutor bean found within the context, and none is named " +
                            "'taskExecutor'. Mark one of them as primary or name it 'taskExecutor' (possibly " +
                            "as an alias) in order to use it for async processing: " + ex.getBeanNamesFound());
                }
            }
        }
        catch (NoSuchBeanDefinitionException ex) {
            logger.debug("Could not find default TaskExecutor bean", ex);
            try {
                // 若找不到TaskExecutor类型Bean，则继续根据名称"taskExecutor"查找Executor类型Bean
                return beanFactory.getBean(DEFAULT_TASK_EXECUTOR_BEAN_NAME, Executor.class);
            }
            catch (NoSuchBeanDefinitionException ex2) {
                logger.info("No task executor bean found for async processing: " +
                        "no bean of type TaskExecutor and no bean named 'taskExecutor' either");
            }
            // Giving up -> either using local default executor or none at all...
        }
    }
    return null;
}

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

protected void handleError(Throwable ex, Method method, Object... params) throws Exception {
    if (Future.class.isAssignableFrom(method.getReturnType())) {
        // 如果Method返回值为Future，则rethrow异常
        ReflectionUtils.rethrowException(ex);
    }
    else {
        // Could not transmit the exception to the caller with default executor
        try {
            // 使用异常处理器处理异常
            this.exceptionHandler.handleUncaughtException(ex, method, params);
        }
        catch (Throwable ex2) {
            logger.error("Exception handler for async method '" + method.toGenericString() +
                    "' threw unexpected exception itself", ex2);
        }
    }
}

AsyncExecutionInterceptor重写了getDefaultExecutor方法，确保默认执行器存在；且实现MethodInterceptor的invoke方法，代码如下：

protected Executor getDefaultExecutor(@Nullable BeanFactory beanFactory) {
    Executor defaultExecutor = super.getDefaultExecutor(beanFactory);
    // 当找不到默认执行器，则使用SimpleAsyncTaskExecutor
    return (defaultExecutor != null ? defaultExecutor : new SimpleAsyncTaskExecutor());
}

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());
}

AsyncAnnotationBeanPostProcessor实现了getExecutorQualifier，从而支持@Async注解，代码如下：

protected String getExecutorQualifier(Method method) {
    // Maintainer's note: changes made here should also be made in
    // AnnotationAsyncExecutionAspect#getExecutorQualifier
    // 获取Method上的Async注解
    Async async = AnnotatedElementUtils.findMergedAnnotation(method, Async.class);
    if (async == null) {
        // 获取Method所在类上的Async注解
        async = AnnotatedElementUtils.findMergedAnnotation(method.getDeclaringClass(), Async.class);
    }
    // 使用Async注解的value属性值，若存在的话
    return (async != null ? async.value() : null);
}

常见问题

@Async注解失效

原因
一般是调用同一个类中的@Async注解标注的方法，此时无法经过AOP处理，导致异步执行失效；

解决方法
在调用方法中，从Bean容器中获取本类的代理实例，使用代理实例调用@Asyc注解标注的方法；

@Autowired
private ApplicationContext applicationContext;

public void invoke() {
    System.out.println("当前线程：" + Thread.currentThread().getName());
    Demo demo = applicationContext.getBean(Demo.class);
    demo.async();
}

@Async
public void async() {
    // do something
    System.out.println("当前线程：" + Thread.currentThread().getName());
}
我家有猫已长成
关注
专栏目录
spring boot 2.1学习笔记【九】SpringBoot 2 集成redis
刘本龙的专栏
01-11 4954
springboot2.X 集成redis非常简单，只需要引入依赖包，配置数据源连接池，就可以直接使用redisTemplate了。 注意：springboot 2.X 版本使用lettuce连接池来替换jedis。Lettuce和Jedis都是连接Redis Server的客户端程序，Jedis在实现上是直连redis server，多线...
Springboot 整合 WebSocket ，使用STOMP协议 ，前后端整合实战 （一）
最新发布
2401_84092483的博客
04-20 895
给大家分享一些关于HTML的面试题，有需要的朋友可以戳这里免费领取，先到先得哦。想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-nblJUGJd-1713557935446)]
配置多个线程池 注册bean 需要注意
weixin_43850799的博客
03-25 1205
主要有一个需要加上@Primary @Configuration @EnableAsync public class ThreadPoolTaskConfig { @Bean @Primary public ThreadPoolTaskExecutor asyncServiceExecutor() { ThreadPoolTaskExecutor exe...
Spring源码：@EnableAsync与@Async源码分析
博客园
08-13 4141
目录 1. @EnableAsync开启异步化支持 2.ProxyAsyncConfiguration异步代理配置类 3. AsyncAnnotationBeanPostProcessor 3.1BeanFactoryAware实现逻辑 3.1.1 异步注解增强/拦截器AnnotationAsyncExecutionInterceptor的原理 3.1.2 切点Annotation...
SpringBoot中@EnableAsync
DN金猿的博客
10-07 1107
在Java应用中，绝大多数情况下都是通过同步的方式来实现交互处理的；但是在处理与第三方系统交互的时候，容易造成响应迟缓的情况，之前大部分都是使用多线程来完成此类任务，其实，在spring3.x之后，就已经内置了@Async来完美解决这个问题 1. 何为异步调用？ 在解释异步调用之前，我们先来看同步调用的定义；同步就是整个处理过程顺序执行，当各个过程都执行完毕，并返回结果。 异步调用则是只是发送了调用的指令，调用者无需等待被调用的方法完全执行完毕；而是继续执行下面的流程。 例如...
SpringBoot 中使用异步线程池 @EnableAsync @Async
u013071319的博客
06-10 2856
各位看官老爷在阅读本篇之前， 最好对 Java 的线程池 ThreadPoolExecutor 有所了解。 在项目的实际应用中，很多时候一个请求都是在同一个线程中运行的。但有时候可能需要异步，也就是一个请求可能存在多个线程。 在Spring中， 存在一个接口叫做 AsyncConfigurer, 这是一个可配置异步线程池的接口： package org.springframework.scheduling.......
实战Spring Boot 2.0系列(三) - 使用@Async进行异步调用详解
weixin_34248258的博客
06-18 602
前言 异步调用 对应的是 同步调用，同步调用 指程序按照 定义顺序 依次执行，每一行程序都必须等待上一行程序执行完成之后才能执行；异步调用 指程序在顺序执行时，不等待 异步调用的语句 返回结果 就执行后面的程序。 本系列文章 实战Spring Boot 2.0系列(一) - 使用Gradle构建Docker镜像 实战Spring Boot 2.0系列(二) - 全局异常处理和测试 实战Sp...
Spring Boot源码简析(二)
feiying的博客
01-22 229
Spring Boot源码简析(二) load 资源过程 在上一篇博客中我们说了SpringApplication的主要启动逻辑，其中context创建之后第一步就是执行 load(context, sources.toArray(new Object[sources.size()])); load主要就是把我们传入的资源生成相应的BeanDefinition。 protecte
spring cloud alibaba整合 nacos config源码简析
雷X峰
12-29 2225
在sprig boot 中，引入`nacos-config-spring-boot-starter`后，通常是使用`@NacosValue`注解来获取nacos server 中的配置以及自动刷新. 在spring cloud alibaba中，引入`spring-cloud-starter-alibaba-nacos-config`则使用了更优雅的方式支持spring 原生注解@Value来获取参数，通过 Spring Cloud 原生注解 @RefreshScope 实现配置自动更新
spring cloud 中Environment参数自定义扩展配置源码简析和实例
雷X峰
12-28 2451
在spring cloud中Environment的扩展配置还可以借助PropertySourceBootstrapConfiguration这个ApplicationContextInitializer,通过自定义类实现PropertySourceLocator接口来扩展。
spring boot注解 --@EnableAsync 异步调用
weixin_34370347的博客
06-23 85
EnableAsync注解的意思是可以异步执行，就是开启多线程的意思。可以标注在方法、类上。 @Component public class Task { @Async public void doTaskOne() throws Exception { // 同上内容，省略 } @Async public voi...
SpringBoot中@EnableAsync和@Async注解的使用
ACGkaka的博客
04-24 9189
SpringBoot中@EnableAsync和@Async注解的使用
SpringBoot：详解@EnableAsync + @Async 实现共享线程池
Oxye
07-27 9011
锲子 平时的开发中，可以看到很多地方要使用多线程技术， 比如 1.处理大数据量的数据时，可以采用线程池，充分利用多核优势 2.用户触发一个较长的流程时，可以将一部分处理逻辑，另起一个线程异步处理，减少用户等待时间 不过线程是一种宝贵的资源，一个系统运行在服务器上，要根据CPU的数量来合理设置并发线程数量。 如果一个系统中每个线程使用者都自己定义线程或者线程池，有一些可见的不良后果 比如 1.系统各处启线程太多，导致CPU切换上下文的消耗 2.定义线程池的参数不一致，导致各种不同实现共存难以处理和排查问题
Spring Boot - @EnableAsync
A_bad_horse的专栏
12-31 133
Spring Boot - @EnableAsync
Springboot @EnableAsync@Async
紫蝶侠的博客
06-18 196
@EnableAsync和@Async Springboot中的@EnableAsync和@Async的作用和基本用法
java多线程教程系列（二）——springboot@Async+@EnableAsync两步开启多线程，常见的多线程的应用场景以及@Async不生效的解决方案
ratel的博客
01-06 2756
java多线程教程系列（二）-------springboot@Async+@EnableAsync两步开启多线程，常见的多线程的应用场景以及@Async不生效的解决方案
Spring boot @EnableAsync与@Async源码分析
03-09 628
目录1. @EnableAsync开启异步化支持2. ProxyAsyncConfiguration异步代理配置类3. AsyncAnnotationBeanPostProcessor3...
SpringBoot异步任务@EnableAsync
Kevin_Gu6的博客
03-11 406
1、启动类加注解@EnableAsync开启异步任务，自动扫描： import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.scheduling.annotat...
@EnableAsync的使用、进阶、源码分析
yubaojin的博客
03-09 7297
@EnableAsync使用、进阶、源码
Spring Boot异步调用@Async实战教程
在Spring Boot集成教程中，异步调用Async功能对于提升应用程序性能和用户体验至关重要。当我们遇到项目中的耗时操作，如网络请求、数据库查询或复杂的计算任务，如果这些操作阻塞了主线程，会导致应用程序响应变慢。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值