SpringBoot中的异步执行方法详解

 更新时间:2023年10月19日 08:33:41   作者:yfs1024  
这篇文章主要介绍了SpringBoot中的异步执行方法详解,ThreadpoolTaskExecutor不需要手动的创建当前线程池,但往往我们还是会手动指定,具体原因看源码就可以自有判断,需要的朋友可以参考下

源码跟踪

简单描述

在SpringBoot2.0.9之前需要手动自定义线程池(如下2.1), 然后指定线程池的名称

SpringBoot2.0.9以及之前的版本,使用的线程池默认是SimpleAsyncTaskExcutor, 之后的版本使用的是ThreadpoolTaskExecutor

并且不需要手动的创建当前线程池(但往往我们还是会手动指定,具体原因看源码就可以自有判断 )

SpringBoot会自动的扫描两个文件下的配置信息:

所以如果我们写的配置类想让SpringBoot自动扫描到就可以放到两个中的任意一个

我们项目中就是这样使用的:在 spring.factories文件中指定一些配置类相对路径,这样配置类中的指定的Bean就可以放入到IOC容器中了

SpringBoot在org.springframework.boot.autoconfigure.AutoConfiguration.imports118行配置了TaskExecutionAutoConfiguration的位置,这样SpringBoot就可以扫描到当前配置类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sOUosu98-1685781636628)(C:\Users\57589\AppData\Roaming\Typora\typora-user-images\image-20230603155549533.png)]

TaskExecutionAutoConfiguration

配置类信息如下

@ConditionalOnClass({ThreadPoolTaskExecutor.class})   // 代表如果容器中有这个类,就不在创建
@AutoConfiguration
@EnableConfigurationProperties({TaskExecutionProperties.class})  // 配置文件
public class TaskExecutionAutoConfiguration {
    // 应用程序任务执行器任务名称 applicationTaskExecutor
    public static final String APPLICATION_TASK_EXECUTOR_BEAN_NAME = "applicationTaskExecutor";

    public TaskExecutionAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean
    public TaskExecutorBuilder taskExecutorBuilder(TaskExecutionProperties properties, ObjectProvider<TaskExecutorCustomizer> taskExecutorCustomizers, ObjectProvider<TaskDecorator> taskDecorator) {
        Pool pool = properties.getPool();
        TaskExecutorBuilder builder = new TaskExecutorBuilder();
        builder = builder.queueCapacity(pool.getQueueCapacity());
        builder = builder.corePoolSize(pool.getCoreSize());
        builder = builder.maxPoolSize(pool.getMaxSize());
        builder = builder.allowCoreThreadTimeOut(pool.isAllowCoreThreadTimeout());
        builder = builder.keepAlive(pool.getKeepAlive());
        Shutdown shutdown = properties.getShutdown();
        builder = builder.awaitTermination(shutdown.isAwaitTermination());
        builder = builder.awaitTerminationPeriod(shutdown.getAwaitTerminationPeriod());
        builder = builder.threadNamePrefix(properties.getThreadNamePrefix());
        Stream var10001 = taskExecutorCustomizers.orderedStream();
        var10001.getClass();
        builder = builder.customizers(var10001::iterator);
        builder = builder.taskDecorator((TaskDecorator)taskDecorator.getIfUnique());
        return builder;
    }

    @Lazy
    @Bean(
        name = {"applicationTaskExecutor", "taskExecutor"}
    )
    @ConditionalOnMissingBean({Executor.class})
    public ThreadPoolTaskExecutor applicationTaskExecutor(TaskExecutorBuilder builder) {
        return builder.build();
    }

TaskExecutionProperties

配置文件中

定义了线程名 task -

ThreadPoolTaskExecutor

public class ThreadPoolTaskExecutor extends ExecutorConfigurationSupport
		implements AsyncListenableTaskExecutor, SchedulingTaskExecutor {

	private final Object poolSizeMonitor = new Object();

	private int corePoolSize = 1;

	private int maxPoolSize = Integer.MAX_VALUE;

	private int keepAliveSeconds = 60;

	private int queueCapacity = Integer.MAX_VALUE;

	private boolean allowCoreThreadTimeOut = false;

	private boolean prestartAllCoreThreads = false;
	
	//       ......  ......................省略
	// 创建代码
	@Override
	protected ExecutorService initializeExecutor(
			ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) {

		BlockingQueue<Runnable> queue = createQueue(this.queueCapacity);

		ThreadPoolExecutor executor;
		if (this.taskDecorator != null) {
            // 还是 new ThreadPoolExecutor
			executor = new ThreadPoolExecutor(
					this.corePoolSize, this.maxPoolSize, this.keepAliveSeconds, TimeUnit.SECONDS,
					queue, threadFactory, rejectedExecutionHandler) {
				@Override
				public void execute(Runnable command) {
					Runnable decorated = taskDecorator.decorate(command);
					if (decorated != command) {
						decoratedTaskMap.put(decorated, command);
					}
					super.execute(decorated);
				}
			};
		}
		else {
			executor = new ThreadPoolExecutor(
					this.corePoolSize, this.maxPoolSize, this.keepAliveSeconds, TimeUnit.SECONDS,
					queue, threadFactory, rejectedExecutionHandler);
		}

		if (this.allowCoreThreadTimeOut) {
			executor.allowCoreThreadTimeOut(true);
		}
		if (this.prestartAllCoreThreads) {
			executor.prestartAllCoreThreads();
		}

		this.threadPoolExecutor = executor;
		return executor;
	}

测试代码:

// 注入
@Autowired
private ThreadPoolTaskExecutor executor;

@Test
public void testThreadPool(){
    System.out.println(executor);
    System.out.println("默认前缀:"+executor.getThreadNamePrefix());
    System.out.println("默认核心线程数:"+executor.getCorePoolSize());
    System.out.println("默认最大线程数:"+executor.getMaxPoolSize());
    System.out.println("当前活跃线程数:"+executor.getActiveCount());
    System.out.println("临时线程空闲时间:"+executor.getKeepAliveSeconds());
    System.out.println("队列最大值:"+executor.getQueueCapacity());
    System.out.println("队列数量:"+executor.getQueueSize());
}

结果如下:

org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor@7410c197
默认前缀:task-
默认核心线程数:8
默认最大线程数:2147483647
当前活跃线程数:0
临时线程空闲时间:60
队列最大值:2147483647
队列数量:0

我们可以看到SpringBoot中默认配置的线程池的数量, 很不符合我们的实际要求, 而且还容易发生OOM(Out Of Memory)

所以我们一般是手动指定线程池中的信息

SpringBoot异步执行方法

定义一个配置类

SpringBoot底层对手动注入的Bean采用的名称如果不在@Bean注解后面指定默认采用的是方法名

即: 这里的 generateExchangeCodeExecutor

@Slf4j
@Configuration
public class PromotionConfig {

    @Bean
    public Executor generateExchangeCodeExecutor(){
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 1.核心线程池大小
        executor.setCorePoolSize(2);
        // 2.最大线程池大小
        executor.setMaxPoolSize(5);
        // 3.队列大小
        executor.setQueueCapacity(200);
        // 4.线程名称
        executor.setThreadNamePrefix("exchange-code-handler-");
        // 5.拒绝策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

在启动类上添加注解

@EnableAsync

在想要异步执行的方法上添加 @Async()注解

并指定ThreadPoolTaskExecutor 执行器的名称

    @Override
    @Async("generateExchangeCodeExecutor")
    public void asyncGenerateCode(Coupon coupon) {
    		......
    }

到此这篇关于SpringBoot中的异步执行方法详解的文章就介绍到这了,更多相关SpringBoot异步执行内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • 如何使用两个栈实现队列Java

    如何使用两个栈实现队列Java

    这篇文章主要介绍了如何使用两个栈实现队列Java,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2019-11-11
  • 使用Zookeeper实现分布式锁

    使用Zookeeper实现分布式锁

    这篇文章主要介绍了使用Zookeeper实现分布式锁,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2022-10-10
  • Java多线程中线程的两种创建方式及比较代码示例

    Java多线程中线程的两种创建方式及比较代码示例

    这篇文章主要介绍了Java多线程中线程的两种创建方式及比较代码示例,简单介绍了线程的概念,并行与并发等,然后通过实例代码向大家展示了线程的创建,具有一定参考价值,需要的朋友可以了解下。
    2017-11-11
  • Java数组(Array)最全汇总(下篇)

    Java数组(Array)最全汇总(下篇)

    这篇文章主要介绍了Java数组(Array)最全汇总(下篇),本文章内容详细,通过案例可以更好的理解数组的相关知识,本模块分为了三部分,本次为下篇,需要的朋友可以参考下
    2023-01-01
  • Java实现的剪刀石头布游戏示例

    Java实现的剪刀石头布游戏示例

    这篇文章主要介绍了Java实现的剪刀石头布游戏,涉及java随机数生成及逻辑判定等相关操作技巧,需要的朋友可以参考下
    2017-12-12
  • Mybatis使用JSONObject接收数据库查询的方法

    Mybatis使用JSONObject接收数据库查询的方法

    这篇文章主要介绍了Mybatis使用JSONObject接收数据库查询,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2021-12-12
  • springboot使用nacos的示例详解

    springboot使用nacos的示例详解

    这篇文章主要介绍了springboot使用nacos的示例代码,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2021-12-12
  • 谈谈对Java多态性的一点理解

    谈谈对Java多态性的一点理解

    多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定
    2017-08-08
  • Java不可不知的泛型使用示例代码

    Java不可不知的泛型使用示例代码

    这篇文章主要介绍了Java不可不知的泛型使用,本文通过实例代码给大家介绍了java的泛型的基本使用,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-08-08
  • IDEA安装详细步骤(多图预警)

    IDEA安装详细步骤(多图预警)

    这篇文章主要介绍了IDEA安装详细步骤(多图预警),本文通过图文并茂的形式给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-04-04

最新评论