Spring Boot 配置线程池详解，并使用@Async，执行异步方法

最新推荐文章于 2024-07-24 21:47:59 发布
最新推荐文章于 2024-07-24 21:47:59 发布
阅读量9.8k 收藏 19
点赞数 7
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43813937/article/details/104532261
版权

Spring Boot 配置线程池详解

线程池是多线程的处理机制，线程池一般用于需要大量线程完成任务，并且完成时间较短时使用，大量用于并发框架和异步执行任务。

一、配置线程池的优势

  • 降低资源消耗，通过利用已创建的线程降低线程创建和销毁造成的消耗
  • 有利于线程的可控性，如果线程无休止创建，会导致内存耗尽。
  • 提高系统响应速度，通过使用已存在的线程，不需要等待新线程的创建就可以立即执行当前任务。

二、spring中线程池ThreadPoolTaskExecutor的主要参数说明。

  • corePoolSize：核心线程数，默认的核心线程的1，向线程池提交一个任务时，如果线程池已经创建的线程数小于核心线程数，即使此时存在空闲线程，也会通过创建一个新线程来执行新任务，知道创建的线程等于核心线程数时，如果有空闲线程，则使用空闲线程。
  • maxPoolSize：最大线程数，默认的最大线程数为Integer.MAX_VALUE 即231-1。当队列满了之后
  • keepAliveSeconds：允许线程空闲时间，默认的线程空闲时间为60秒，当线程中的线程数大于核心线程数时，线程的空闲时间如果超过线程的存活时间，则此线程会被销毁，直到线程池中的线程数小于等于核心线程数时。
  • queueCapacity：缓冲队列数，默认的缓冲队列数是Integer.MAX_VALUE 即231-1，用于保存执行任务的阻塞队列
  • allowCoreThreadTimeOut：销毁机制，allowCoreThreadTimeOut为true则线程池数量最后销毁到0个。allowCoreThreadTimeOut为false销毁机制：超过核心线程数时，而且（超过最大值或者timeout过），就会销毁。默认是false

三、Spring Boot 中创建线程池ThreadPoolTaskExecutor

/**
 * @author yly
 * @ClassName ThreadPoolConfig
 * @Date 2020/2/26 12:10
 * @Version 1.0
 **/
@Configuration
public class ThreadPoolConfig {

        /**
     * 核心线程数
     * 默认的核心线程数为1
     *
     */
    private static final int CORE_POOL_SIZE = 5;
    /**
     * 最大线程数
     * 默认的最大线程数是Integer.MAX_VALUE 即2<sup>31</sup>-1
     */
    private static final int MAX_POOL_SIZE = 50;
    /**
     * 缓冲队列数
     * 默认的缓冲队列数是Integer.MAX_VALUE 即2<sup>31</sup>-1
     */
    private static final int QUEUE_CAPACITY = 100;

    /**
     * 允许线程空闲时间
     * 默认的线程空闲时间为60秒
     */
    private static final int KEEP_ALIVE_SECONDS = 30;

    /**
     * 线程池前缀名
     */
    private static final String THREAD_NAME_PREFIX = "Task_Service_Async_";

    /**
     * allowCoreThreadTimeOut为true则线程池数量最后销毁到0个
     * allowCoreThreadTimeOut为false
     * 销毁机制：超过核心线程数时，而且（超过最大值或者timeout过），就会销毁。
     * 默认是false
     */
    private boolean allowCoreThreadTimeOut = false;

    @Bean("taskExecutor")
    public ThreadPoolTaskExecutor taskExecutor() {

        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(CORE_POOL_SIZE);
        taskExecutor.setMaxPoolSize(MAX_POOL_SIZE);
        taskExecutor.setQueueCapacity(QUEUE_CAPACITY);
        taskExecutor.setKeepAliveSeconds(KEEP_ALIVE_SECONDS);
        taskExecutor.setThreadNamePrefix(THREAD_NAME_PREFIX);
        taskExecutor.setAllowCoreThreadTimeOut(allowCoreThreadTimeOut);
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //线程池初始化
        taskExecutor.initialize();
        return taskExecutor;
    }
 }

其中setRejectedExecutionHandler()设置拒绝执行处理程序。

	/**
	 * Set the RejectedExecutionHandler to use for the ExecutorService.
	 * Default is the ExecutorService's default abort policy.
	 * @see java.util.concurrent.ThreadPoolExecutor.AbortPolicy
	 */
	public void setRejectedExecutionHandler(@Nullable RejectedExecutionHandler rejectedExecutionHandler) {
		this.rejectedExecutionHandler =
				(rejectedExecutionHandler != null ? rejectedExecutionHandler : new ThreadPoolExecutor.AbortPolicy());
	}

ThreadPoolTaskExecutor 的拒绝执行处理程序共有四种，在ThreadPoolExecutor类中
线程池

第一种处理程序CallerRunsPolicy
  /**
     * A handler for rejected tasks that runs the rejected task
     * directly in the calling thread of the {@code execute} method,
     * unless the executor has been shut down, in which case the task
     * is discarded.
     */
    public static class CallerRunsPolicy implements RejectedExecutionHandler {

被拒绝任务的处理程序，它直接在{@code execute}方法的调用线程中运行被拒绝的任务，除非执行程序已经关闭，在这种情况下任务被丢弃。

第二种处理程序AbortPolicy
  /**
     * A handler for rejected tasks that throws a
     * {@code RejectedExecutionException}.
     */
    public static class AbortPolicy implements RejectedExecutionHandler {

抛出{@code RejectedExecutionException}的被拒绝任务的处理程序。

第三种处理程序DiscardOldestPolicy
  /**
     * A handler for rejected tasks that discards the oldest unhandled
     * request and then retries {@code execute}, unless the executor
     * is shut down, in which case the task is discarded.
     */
    public static class DiscardOldestPolicy implements RejectedExecutionHandler {

被拒绝任务的处理程序，它丢弃最古老的未处理请求，然后重试{@code execute}，除非执行程序关闭，在这种情况下任务被丢弃。

第四种处理程序DiscardPolicy
  /**
     * A handler for rejected tasks that silently discards the
     * rejected task.
     */
    public static class DiscardPolicy implements RejectedExecutionHandler {

一个处理被拒绝任务的处理程序，它无声地丢弃被拒绝的任务。

四、Spring Boot 中创建线程池ThreadPoolTaskScheduler

/**
 * @author yly
 * @ClassName ThreadPoolConfig
 * @Date 2020/2/26 12:10
 * @Version 1.0
 **/
@Configuration
public class ThreadPoolConfig {

    /**
     * 设置调度的执行程序服务的池大小。
     */
    private int poolSize = 4;
    /**
     * 设置任务注册器的调度器
     * 在{@link ScheduledThreadPoolExecutor}上设置取消操作模式。默认是{@code false}。
     * 如果设置为{@code true}，则目标执行程序将切换到“删除-取消”模式(如果可能，则使用软回退)。
     * 这个设置可以在运行时修改，例如通过JMX。
     *
     */
    private boolean removeOnCancelPolicy = true;
    /**
     * 线程池前缀名
     */
    private String threadNamePrefix = "TaskSchedulerThreadPool-";

    @Bean("taskScheduler")
    public ThreadPoolTaskScheduler taskScheduler(){
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();

        scheduler.setPoolSize(poolSize);

        scheduler.setRemoveOnCancelPolicy(removeOnCancelPolicy);

        scheduler.setThreadNamePrefix(threadNamePrefix);
        return scheduler;
    }
}

ThreadPoolTaskScheduler参数说明

  • poolSize ：设置调度的执行程序服务的池大小。
  • removeOnCancelPolicy ： * 设置任务注册器的调度器在{@link ScheduledThreadPoolExecutor}上设置取消操作模式。默认是{@code false}。如果设置为{@code true}，则目标执行程序将切换到“删除-取消”模式(如果可能，则使用软回退)。这个设置可以在运行时修改。
  • threadNamePrefix ：线程池前缀名

其中setErrorHandler()方法是自定义错误处理程序策略

五、 线程池的创建流程

创建线程池时，首先判断线程池的核心线程池是否已满，没满则创建新的工作线程执行任务，否则判断任务队列是否已满，没满则将新提交的任务添加到工作队列，否则判断整个线程池是否已满，没满则创建一个新的工作线程来执行任务，否执行饱和策略。

六、线程池参数推荐设置

  • corePoolSize：核心线程数（taskstasktime个线程数），假设系统每秒任务数为100到1000，每个任务耗时0.1秒，则需要1000.1至1000*0.1，即10到100个线程
  • maxPoolSize：最大线程数，每秒200个任务需要20个线程，那么当每秒达到1000个任务时，则需要(1000-queueCapacity)*(20/200)，即60个线程，可将maxPoolSize设置为60。
  • queueCapacity：缓冲队列数，队列长度可以设置为(corePoolSize/tasktime)responsetime： (20/0.1)2=400，即队列长度可设置为400。*

七、使用@Async，异步方法执行

（1）创建SpringBoot web项目
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.yly</groupId>
    <artifactId>async</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>async</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
（2）在启动类上添加@EnableAsync和@EnableScheduling（为了查看使用线程池配置定时任务）
/**
 * @author 81509
 */
@SpringBootApplication
@EnableAsync
@EnableScheduling
public class AsyncApplication {

    public static void main(String[] args) {
        SpringApplication.run(AsyncApplication.class, args);
    }

}
（3）创建SendSmsService
/**
 * @author yly
 * @ClassName SendSmsService
 * @Date 2020/2/26 11:31
 * @Version 1.0
 **/
@Service
@Async("taskExecutor")//可以加在类上或方法上
public class SendSmsService {

    Logger logger = LoggerFactory.getLogger(getClass());

    public void sendMerchant() {
        logger.info("通知商铺--------开始");
        try {
            logger.info("sleep----3秒");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("通知商铺--------完成");
    }

    public void sendConsumer()  {
        logger.info("通知消费者---------开始");
        try {
            logger.info("sleep----1秒");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("通知消费者---------完成");
    }
}
（4）配置线程池
/**
 * @author yly
 * @ClassName ThreadPoolConfig
 * @Date 2020/2/26 12:10
 * @Version 1.0
 **/
@Configuration
public class ThreadPoolConfig {

        /**
     * 核心线程数
     * 默认的核心线程数为1
     *
     */
    private static final int CORE_POOL_SIZE = 5;
    /**
     * 最大线程数
     * 默认的最大线程数是Integer.MAX_VALUE 即2<sup>31</sup>-1
     */
    private static final int MAX_POOL_SIZE = 50;
    /**
     * 缓冲队列数
     * 默认的缓冲队列数是Integer.MAX_VALUE 即2<sup>31</sup>-1
     */
    private static final int QUEUE_CAPACITY = 100;

    /**
     * 允许线程空闲时间
     * 默认的线程空闲时间为60秒
     */
    private static final int KEEP_ALIVE_SECONDS = 30;
    
    /**
     * 线程池前缀名
     */
    private static final String THREAD_NAME_PREFIX = "Task_Service_Async_";

    /**
     * allowCoreThreadTimeOut为true则线程池数量最后销毁到0个
     * allowCoreThreadTimeOut为false
     * 销毁机制：超过核心线程数时，而且（超过最大值或者timeout过），就会销毁。
     * 默认是false
     */
    private boolean allowCoreThreadTimeOut = false;

    @Bean("taskExecutor")
    public ThreadPoolTaskExecutor taskExecutor() {

        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(CORE_POOL_SIZE);
        taskExecutor.setMaxPoolSize(MAX_POOL_SIZE);
        taskExecutor.setQueueCapacity(QUEUE_CAPACITY);
        taskExecutor.setKeepAliveSeconds(KEEP_ALIVE_SECONDS);
        taskExecutor.setThreadNamePrefix(THREAD_NAME_PREFIX);
        taskExecutor.setAllowCoreThreadTimeOut(allowCoreThreadTimeOut);
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        taskExecutor.initialize();
        return taskExecutor;
    }
}
（5）创建demo类调用异步方法，需要加上@Component加入到容器中
/**
 * @author yly
 * @ClassName demo
 * @Date 2020/2/26 11:37
 * @Version 1.0
 **/
@Component
public class demo {

    @Autowired
    private SendSmsService sendSmsService;

    @Scheduled(fixedRate  = 1000)//定时任务，一秒执行一次
    public void test()  {
        sendSmsService.sendMerchant();
        sendSmsService.sendConsumer();
    }
}
（6）执行结果

在这里插入图片描述

CodeRemote
关注
  • 7
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
async spring 默认线程池_Spring boot注解@Async线程池实例详解
weixin_42313675的博客
12-24 2781
这篇文章主要介绍了Spring boot注解@Async线程池实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下从Spring3开始提供了@Async注解，该注解可以被标注在方法上，以便异步地调用该方法。调用者将在调用时立即返回，方法的实际执行将提交给Spring TaskExecutor的任务中，由指定的线程池中的线程执行。1. TaskE...
java spring线程池详解_Spring Boot利用@Async异步调用：ThreadPoolTaskScheduler线程池的优雅关闭详解...
weixin_42518090的博客
02-26 316
前言之前分享了一篇关于Spring Boot中使用@Async来实现异步任务和线程池控制的文章：《Spring Boot使用@Async实现异步调用：自定义线程池》。由于最近身边也发现了不少异步任务没有正确处理而导致的不少问题，所以在本文就接前面内容，继续说说线程池的优雅关闭，主要针对ThreadPoolTaskScheduler线程池。问题现象在上篇文章的例子Chapter4-1-3中，我们定义...
Springboot 通过ThreadPoolTaskScheduler实现定时任务.rar
08-21
1、通过ThreadPoolTaskScheduler、反射机制实现。 2、未开发前端界面，但是任务的添加、修改、启动、暂停、删除我已经写好，在TimmerController中
spring boot中使用@Async实现异步调用任务
08-31
本篇文章主要介绍了spring boot中使用@Async实现异步调用任务，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot线程池配置与使用
IvanWKQ的博客
06-21 180
【代码】SpringBoot线程池配置与使用。
Spring Boot之@Async异步线程池示例详解
weixin_72874338的博客
08-02 1713
Spring Boot之@Async异步线程池
Spring Boot中@Async注解的使用及原理 + 常见问题及解决方案
傲泣龙腾的博客
07-12 5017
在现代Java应用程序中，异步处理是提高性能和响应速度的重要手段之一，比如博主之前分享的【Spring Boot 使用自定义注解和自定义线程池实现异步日志记录】，就是采用了异步处理来实现日志记录，而在中它提供了@Async注解来简化异步编程，今天博主就来和小伙伴们分享本@Async注解的基本使用、实现原理以及应用场景。使用@Async注解定义异步方法
Spring之异步任务@Async详解分析
上善若泪
03-25 8411
在业务场景中，有时需要使用自己定义的执行器来跑异步的业务逻辑，那该怎么办呢？答案是，自定义线程池。在方法上的@Async@Async("MyExecutor") //使用自定义的线程池(执行器) public void asyncCpsItemImportTask(Long platformId , String jsonList) {//...具体业务逻辑 } }
Spring Boot(5) @Async异步线程池详解
黄规速博客:学如逆水行舟，不进则退
06-11 8019
一. Spring异步线程池的接口类 ：TaskExecutor Spring异步线程池的接口类，其实质是java.util.concurrent.Executor Spring 已经实现的异常线程池： 1. SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。 2. SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只适用于不需要多线程的地方 3. ConcurrentTaskExecutor：Executor...
Spring boot注解@Async线程池实例详解
码强的博客
05-11 1695
这篇文章主要介绍了Spring boot注解@Async线程池实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 从Spring3开始提供了@Async注解，该注解可以被标注在方法上，以便异步地调用该方法。调用者将在调用时立即返回，方法的实际执行将提交给Spring TaskExecutor的任务中，由指定的线程池中的线程执行。 1. TaskExecutor Spring异步线程池的接口类，其实质是java.util.concurrent.Ex
Spring Boot利用@Async异步调用：ThreadPoolTaskScheduler线程池的优雅关闭详解
08-27
在Spring Boot应用中，使用`@Async`注解可以方便地实现异步任务，而`ThreadPoolTaskScheduler`作为Spring提供的一个任务调度器，允许我们创建一个定制化的线程池来处理这些异步任务。本文将深入探讨如何优雅地关闭`...
Spring Boot利用@Async异步调用：使用Future及定义超时详解
08-27
在Spring Boot应用中，我们可以利用`@Async`注解实现异步调用，这有助于提高应用程序的并发性能，尤其在处理耗时操作时。本文将详细介绍如何使用`@Async`结合`Future`来处理异步任务，并探讨如何定义超时。 `@Async...
Spring Boot异步调用@Async过程详解
08-25
Spring Boot 异步调用 @Async 过程详解是 Spring Boot 框架中的一种异步调用机制，通过使用 @Async 注解可以将方法异步执行，提高系统的并发性和响应速度。本文将详细介绍 Spring Boot 异步调用 @Async 过程详解的...
Spring Boot Async异步执行任务过程详解
08-18
Spring Boot Async异步执行任务过程详解 Spring Boot Async异步执行任务过程详解主要介绍了Spring Boot中异步执行任务的过程，通过示例代码介绍了非常详细，对大家的学习或者工作具有一定的参考学习价值。 一、...
深入理解Spring的@Async注解：实现异步方法调用
weixin_46993901的博客
06-06 3634
在当今高速发展的应用开发领域，对于提升系统性能和响应能力的需求越来越迫切。而异步编程作为一种解决方案，已经成为现代应用开发中的一项重要技术。本篇博客将带您深入探究 Java 中的 @Async 注解，揭示其强大的异步执行能力和精妙的实现机制。异步编程是一种编程模式，通过将任务分解为多个子任务，并在后台或并行线程中执行这些子任务，以提高程序的性能和响应能力。@Async 注解是 Spring 框架提供的注解，用于将方法标记为异步执行的方法。
Springboot线程池ThreadPoolTaskExecutor与@Async详解使用
qq_40093255的博客
05-19 3052
Springboot整合ThreadPoolTaskExecutor线程池 ThreadPoolExecutor： 这个是java自己实现的线程池执行类，基本上创建线程池都是通过这个类进行的创建 ThreadPoolTaskExecutor：这个是springboot基于ThreadPoolExecutor实现的一个线程池执行类 在springboot当中，根据官方文档官方文档的说明，如果没有配置线程池的话，springboot会自动配置一个ThreadPoolTaskExecutor线程池到bean当
golang 接口
最新发布
m0_70982551的博客
07-24 842
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
springboot 配置线程池 @Async使用该线程池
11-17
以下是Springboot配置线程池并使用@Async注解的方法： 1.在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> ``` 2.创建一个ThreadPoolConfig类，用于配置线程池： ```java @Configuration @EnableAsync public class ThreadPoolConfig implements AsyncConfigurer { @Override public Executor getAsyncExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(10); executor.setMaxPoolSize(20); executor.setQueueCapacity(200); executor.setThreadNamePrefix("MyExecutor-"); executor.initialize(); return executor; } @Override public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() { return new SimpleAsyncUncaughtExceptionHandler(); } } ``` 3.在需要异步执行的方法上添加@Async注解，并指定线程池名称： ```java @Service public class MyService { @Async("myExecutor") public void asyncMethod() { // 异步执行的方法体 } } ``` 4.在Controller中调用异步方法： ```java @RestController public class MyController { @Autowired private MyService myService; @GetMapping("/async") public String async() { myService.asyncMethod(); return "异步方法已经执行"; } } ``` 5.启动应用程序并访问“/async”URL，异步方法将在后台线程池中执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值