【SpringBoot·线程池的使用】

最新推荐文章于 2024-07-28 09:59:00 发布
最新推荐文章于 2024-07-28 09:59:00 发布
阅读量1.2k 收藏 12
点赞数 3
分类专栏： SpringBoot 文章标签： SpringBoot 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y_16041527/article/details/116921462
版权

SpringBoot中使用线程池

ThreadPoolExecutor：这个是JAVA自己实现的线程池执行类，基本上创建线程池都是通过这个类进行的创建！

ThreadPoolTaskExecutor ：这个是springboot基于ThreadPoolExecutor实现的一个线程池执行类。（SpringBoot中用这个！！！！）

SpringBoot中使用ThreadPoolExecutor

application-dev.yml
# 线程池配置
# 核心线程数
threadPool.spring.corePoolSize: 20
# 最大线程数
threadPool.spring.maxPoolSize: 40
# 线程队列长度
threadPool.spring.queueCapacity: 100
# 超过核心线程数的线程所允许的空闲时间
threadPool.spring.keepAliveSeconds: 300
ThreadPoolConfig
package com.biaogexf.Tools.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.*;

/**
 * 线程池配置
 */
@Configuration
public class ThreadPoolConfig {

    @Value("${threadPool.spring.corePoolSize}")
    private Integer corePoolSize;

    @Value("${threadPool.spring.maxPoolSize}")
    private Integer maxPoolSize;

    @Value("${threadPool.spring.queueCapacity}")
    private Integer queueCapacity;

    @Value("${threadPool.spring.keepAliveSeconds}")
    private Integer keepAliveSeconds;

    // SpringBoot中使用ThreadPoolExecutor
    @Bean(name = "threadPoolExecutor")
    public ExecutorService threadPoolExecutor() {
        ExecutorService executor = new ThreadPoolExecutor(corePoolSize, maxPoolSize, keepAliveSeconds, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        return executor;
    }
}
ThreadPoolExecutorTest
package com.biaogexf.Tools.thread.springboot;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import com.biaogexf.tools.ToolsApplication;

import java.util.concurrent.ThreadPoolExecutor;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = ToolsApplication.class)
@Slf4j
public class ThreadPoolExecutorTest {

    @Autowired
    ThreadPoolExecutor threadPoolExecutor;  //会去匹配 @Bean(name = "threadPoolExecutor") 这个线程池

    @Test
    public void testThreadPoolExecutor() {

        for (int i = 0; i < 10; i++) {
            final int index = i;
            // execute用来提交线程的执行
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    log.info("{}:{}", Thread.currentThread().getName(), index);
                }
            });
        }
    }
}

SpringBoot中使用ThreadPoolTaskExecutor

在springboot当中，根据官方文档的说明，如果没有配置线程池的话，springboot会自动配置一个ThreadPoolTaskExecutor 线程池到bean当中，我们只需要按照他的方式调用就可以了！！！

方式一：

第一步：在Application启动类上面加上@EnableAsync

第二步：在需要异步执行的方法上加@Async

方式二：

直接注入ThreadPoolTaskExecutor

package com.biaogexf.tools;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

/**
 * 启动程序
 */
@SpringBootApplication
@EnableAsync // 开启异步   1.在Application启动类上面加上@EnableAsync ！！！！！！！！！！
public class ToolsApplication {

    public static void main(String[] args) {
        System.setProperty("spring.devtools.restart.enabled", "false");
        SpringApplication.run(ToolsApplication.class, args);
    }

}

package com.biaogexf.tools.thread.springboot;

import com.biaogexf.tools.ToolsApplication;
import com.biaogexf.tools.service.AsyncService;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.concurrent.Executor;

/**
 * 在springboot当中，根据 官方文档的说明，如果没有配置线程池的话，
 * springboot会自动配置一个ThreadPoolTaskExecutor 线程池到bean当中，我们只需要按照他的方式调用就可以了！！！
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ToolsApplication.class)
@Slf4j
public class SpringBootDefaultThreadPoolTest {

    // 方式一：@Enable+@Async
    @Autowired
    AsyncService asyncService;

    // 方式二：直接注入ThreadPoolTaskExecutor
    @Autowired
    Executor threadPoolTaskExecutor;

    @Test
    public void testDefaultPool() {
        // 方式一
        for (int i = 0; i < 10; i++) {
            asyncService.helllo(i);
        }

        // 方式二
        for (int j = 0; j < 10; j++) {
            final int index = j;
            threadPoolTaskExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    log.info("threadPoolTaskExecutor 创建线程 异步执行：{}", index);
                }
            });
        }
    }
}


package com.biaogexf.tools.service;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {

    private final Logger log = LoggerFactory.getLogger(AsyncService.class);

    @Async // 2.在需要异步执行的方法上加@Async
    public void helllo(int i) {
        log.info("异步线程启动：{}", i);
    }
}

SpringBoot中使用自定义的线程池 & 配置多个自定义线程池并指定线程池使用

package com.biaogexf.tools.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.*;

/**
 * 线程池配置
 * ThreadPoolTaskExecutor的使用
 * 自定义多个线程池 & 指定线程池使用
 */
@Configuration
public class ThreadPoolConfig {

    @Value("${threadPool.spring.corePoolSize}")
    private Integer corePoolSize;

    @Value("${threadPool.spring.maxPoolSize}")
    private Integer maxPoolSize;

    @Value("${threadPool.spring.queueCapacity}")
    private Integer queueCapacity;

    @Value("${threadPool.spring.keepAliveSeconds}")
    private Integer keepAliveSeconds;

    // SpringBoot中使用ThreadPoolExecutor
    @Bean(name = "threadPoolExecutor")
    public ThreadPoolExecutor threadPoolExecutor() {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maxPoolSize, keepAliveSeconds, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        return executor;
    }

    // 自定义ThreadPoolTaskExecutor线程池
    @Bean(name = "customThreadPoolTaskExecutor")
    public ThreadPoolTaskExecutor customThreadPoolTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 设置线程池参数
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveSeconds);
        executor.setThreadNamePrefix("myExecutor--");
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        // 修改拒绝策略为使用当前线程执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 初始化线程池
        executor.initialize();
        return executor;
    }

    // 自定义ThreadPoolTaskExecutor线程池
    @Bean(name = "customThreadPoolTaskExecutor11111")
    public ThreadPoolTaskExecutor customThreadPoolTaskExecutor1() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 设置线程池参数
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveSeconds);
        executor.setThreadNamePrefix("myExecutor11111--");
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        // 修改拒绝策略为使用当前线程执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 初始化线程池
        executor.initialize();
        return executor;
    }
}

package com.biaogexf.tools.thread.springboot;

import com.biaogexf.tools.ToolsApplication;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * SpringBoot中自定义多个线程池 & 指定线程池使用
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ToolsApplication.class)
@Slf4j
public class SpringBootCustomThreadPoolTest {

    // SpringBoot中使用个性化配置后的ThreadPoolTaskExecutor线程池 自定义线程池 customThreadPoolTaskExecutor
    @Autowired
    private ThreadPoolTaskExecutor customThreadPoolTaskExecutor; // 会去匹配 @Bean("customThreadPoolTaskExecutor") 这个线程池

    // SpringBoot中使用个性化配置后的ThreadPoolTaskExecutor线程池 自定义线程池 customThreadPoolTaskExecutor1
    @Autowired
    private ThreadPoolTaskExecutor customThreadPoolTaskExecutor11111; // 会去匹配 @Bean("customThreadPoolTaskExecutor11111") 这个线程池


    @Test
    public void testCustomThreadPoolTaskExecutor() {
        // SpringBoot中使用自定义线程池 customThreadPoolTaskExecutor
        for (int j = 0; j < 10; j++) {
            final int index = j;
            customThreadPoolTaskExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    log.info("###SpringBoot中使用自定义线程池 customThreadPoolTaskExecutor 创建线程 异步执行：{}", index);
                }
            });
        }

        // SpringBoot中使用自定义线程池 customThreadPoolTaskExecutor1
        for (int j = 0; j < 10; j++) {
            final int index = j;
            customThreadPoolTaskExecutor11111.execute(new Runnable() {
                @Override
                public void run() {
                    log.info("###SpringBoot中使用自定义线程池 customThreadPoolTaskExecutor11111 创建线程 异步执行：{}", index);
                }
            });
        }
    }
}

springboot之线程池ThreadPoolTaskExecutor以及@Async异步注解

在spring boot中使用java线程池ExecutorService

Spring Boot教程(21) – 默认线程池

@Async，@EnableAsync，@AsyncConfigurer实现自定义线程池

在spring中，可以通过@EnableAsync + @Async两个注解非常快捷的实现异步。

但是默认情况下,每一次调用都是开启一个新的线程！

@Async用的是SimpleAsyncTaskExecutor线程池，但是如果没有对SimpleAsyncTaskExecutor做策略配置的话，是不复用线程的，这是对服务器资源的浪费。

使用@EnableAsync + @Async快速实现异步

/**
 * 启动程序
 */
@SpringBootApplication
@EnableAsync // 开启异步
public class ToolsApplication {

    public static void main(String[] args) {
        System.setProperty("spring.devtools.restart.enabled", "true");
        SpringApplication.run(ToolsApplication.class, args);
    }

}

/**
 * 使用@Enable + @Async快速实现异步
 */
@RestController
@RequestMapping("/WxworkAsyncController")
public class WxworkAsyncController {

    @Autowired
    private WxworkAsyncService wxworkAsyncService;

    @GetMapping("async")
    public String async() {
        // 模拟异步处理任务
        wxworkAsyncService.async();
        return "success123213213fffff";
    }
}


/**
 * 使用@Enable + @Async快速实现异步
 */
@Service
public class WxworkAsyncService {

    private static final Logger log = LoggerFactory.getLogger(WxworkAsyncService.class);

    @Async
    public void async() {
        try {
            // 模拟业务执行操作
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            log.error("### WxworkAsyncService InterruptedException ", e);
        }
        log.info("{} -- {}", System.currentTimeMillis(), Thread.currentThread().getName());
    }
}

21-05-17.10:21:16.441 [SimpleAsyncTaskExecutor-1] INFO WxworkAsyncService - 1621218076441 – SimpleAsyncTaskExecutor-1
21-05-17.10:21:32.944 [SimpleAsyncTaskExecutor-2] INFO WxworkAsyncService - 1621218092944 – SimpleAsyncTaskExecutor-2
21-05-17.10:21:33.445 [SimpleAsyncTaskExecutor-3] INFO WxworkAsyncService - 1621218093445 – SimpleAsyncTaskExecutor-3
21-05-17.10:21:33.764 [SimpleAsyncTaskExecutor-4] INFO WxworkAsyncService - 1621218093764 – SimpleAsyncTaskExecutor-4
21-05-17.10:21:34.052 [SimpleAsyncTaskExecutor-5] INFO WxworkAsyncService - 1621218094052 – SimpleAsyncTaskExecutor-5
21-05-17.10:21:34.509 [SimpleAsyncTaskExecutor-6] INFO WxworkAsyncService - 1621218094509 – SimpleAsyncTaskExecutor-6
21-05-17.10:21:34.935 [SimpleAsyncTaskExecutor-7] INFO WxworkAsyncService - 1621218094935 – SimpleAsyncTaskExecutor-7
21-05-17.10:21:35.139 [SimpleAsyncTaskExecutor-8] INFO WxworkAsyncService - 1621218095139 – SimpleAsyncTaskExecutor-8
21-05-17.10:21:35.523 [SimpleAsyncTaskExecutor-9] INFO WxworkAsyncService - 1621218095523 – SimpleAsyncTaskExecutor-9
21-05-17.10:21:35.905 [SimpleAsyncTaskExecutor-10] INFO WxworkAsyncService - 1621218095905 – SimpleAsyncTaskExecutor-10
21-05-17.10:21:36.272 [SimpleAsyncTaskExecutor-11] INFO WxworkAsyncService - 1621218096272 – SimpleAsyncTaskExecutor-11
21-05-17.10:21:36.630 [SimpleAsyncTaskExecutor-12] INFO WxworkAsyncService - 1621218096630 – SimpleAsyncTaskExecutor-12
21-05-17.10:21:36.990 [SimpleAsyncTaskExecutor-13] INFO WxworkAsyncService - 1621218096990 – SimpleAsyncTaskExecutor-13
21-05-17.10:21:37.341 [SimpleAsyncTaskExecutor-14] INFO WxworkAsyncService - 1621218097341 – SimpleAsyncTaskExecutor-14
21-05-17.10:21:37.687 [SimpleAsyncTaskExecutor-15] INFO WxworkAsyncService - 1621218097687 – SimpleAsyncTaskExecutor-15
21-05-17.10:21:38.032 [SimpleAsyncTaskExecutor-16] INFO WxworkAsyncService - 1621218098032 – SimpleAsyncTaskExecutor-16
21-05-17.10:21:38.364 [SimpleAsyncTaskExecutor-17] INFO WxworkAsyncService - 1621218098364 – SimpleAsyncTaskExecutor-17
21-05-17.10:21:38.726 [SimpleAsyncTaskExecutor-18] INFO WxworkAsyncService - 1621218098726 – SimpleAsyncTaskExecutor-18

自定义线程池

自定义线程池很简单，只要实现AsyncConfigurer接口，并且重写getAsyncExecutor方法。

也可以重新getAsyncUncaughtExceptionHandler方法，实现自定义异常处理类。

当implements AsyncConfigurer 接口，实现了自定义线程池后，会默认覆盖springboot自带的异步线程池

package com.biaogexf.tools.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.lang.reflect.Method;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 实现AsyncConfigurer接口，自定义线程池，并通过@Async注解使用 (该注解使用在需要在新线程中执行的方法上)
 *
 * @Async 注解在service内的方法上(@EnableAsync开启异步)，可以实现在controller的异步调用，
 * 调用的被@Async注解的方法会在一个单独线程内运行，适合即使返回，异步解耦，service慢慢去处理
 *
 * @Async 注解的方法只能 返回void或者future类型的返回值，其他值会使 注解无效，因为不能异步执行
 * 
 * 当implements AsyncConfigurer接口实现了自定义的异步线程池后，会默认覆盖spring自带的异步线程池
 */
@Configuration
@EnableAsync
@Slf4j
public class SpringThreadPoolConfig implements AsyncConfigurer {

    @Value("${threadPool.spring.corePoolSize}")
    private Integer corePoolSize;

    @Value("${threadPool.spring.maxPoolSize}")
    private Integer maxPoolSize;

    @Value("${threadPool.spring.queueCapacity}")
    private Integer queueCapacity;

    @Value("${threadPool.spring.keepAliveSeconds}")
    private Integer keepAliveSeconds;

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(corePoolSize);
        taskExecutor.setMaxPoolSize(maxPoolSize);
        taskExecutor.setQueueCapacity(queueCapacity);
        taskExecutor.setKeepAliveSeconds(keepAliveSeconds);
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        taskExecutor.setThreadNamePrefix("MyAsync-");
        taskExecutor.initialize();
        return taskExecutor;
    }

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

/**
 * 自定义异常处理类
 * 被 @Async 修饰的方法在独立线程调用，不能被@ControllerAdvice全局异常处理器捕获，所以需要自己设置异常处理
 */
@Slf4j
class MyAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {

    @Override
    public void handleUncaughtException(Throwable throwable, Method method, Object... objects) {
        log.info("Exception message - " + throwable.getMessage());
        log.info("Method name - " + method.getName());
        for (Object param: objects) {
            log.info("Parameter value - " + param);
        }
        log.error("handleUncaughtException method:" + method.getName(), throwable);
    }
}

21-05-17.11:00:32.289 [MyAsync-1 ] INFO WxworkAsyncService - 1621220432289 – MyAsync-1
21-05-17.11:00:34.512 [MyAsync-2 ] INFO WxworkAsyncService - 1621220434512 – MyAsync-2
21-05-17.11:00:34.880 [MyAsync-3 ] INFO WxworkAsyncService - 1621220434880 – MyAsync-3
21-05-17.11:00:35.252 [MyAsync-4 ] INFO WxworkAsyncService - 1621220435252 – MyAsync-4
21-05-17.11:00:35.639 [MyAsync-5 ] INFO WxworkAsyncService - 1621220435639 – MyAsync-5
21-05-17.11:00:36.188 [MyAsync-1 ] INFO WxworkAsyncService - 1621220436188 – MyAsync-1
21-05-17.11:00:36.569 [MyAsync-2 ] INFO WxworkAsyncService - 1621220436569 – MyAsync-2
21-05-17.11:00:39.163 [MyAsync-3 ] INFO WxworkAsyncService - 1621220439163 – MyAsync-3
21-05-17.11:00:39.522 [MyAsync-4 ] INFO WxworkAsyncService - 1621220439522 – MyAsync-4
21-05-17.11:00:40.003 [MyAsync-5 ] INFO WxworkAsyncService - 1621220440003 – MyAsync-5
21-05-17.11:00:43.637 [MyAsync-1 ] INFO WxworkAsyncService - 1621220443637 – MyAsync-1
21-05-17.11:00:51.359 [MyAsync-2 ] INFO WxworkAsyncService - 1621220451359 – MyAsync-2
21-05-17.11:01:01.652 [MyAsync-3 ] INFO WxworkAsyncService - 1621220461652 – MyAsync-3

@ASYNC，@ENABLEASYNC，ASYNCCONFIGURER 自定义线程池

感悟

在SpringBoot中使用线程池必须根据业务场景自定义配置线程池核心参数&实现自定义线程池！！！不可用SpringBoot中默认自带的线程池去执行任务，因为这样不可控！

biaogexf
关注
专栏目录
深入学习springboot线程池的使用和扩展
08-25
深入学习SpringBoot线程池的使用和扩展 在本篇文章中，我们将深入学习SpringBoot框架提供的线程池服务，并了解如何使用和扩展它。SpringBoot框架提供了@Async注解，帮助我们更方便的将业务逻辑提交到线程池中异步...
springboot 线程池
PurineKing之博客
01-28 1万+
springboot 线程池
Java线程池详解
qq_35354529的博客
04-08 2917
@Configuration public class ThreadPoolConfig { /** * IO密集型任务 = 一般为2*CPU核心数（常出现于线程中：数据库数据交互、文件上传下载、网络数据传输等等） * CPU密集型任务 = 一般为CPU核心数+1（常出现于线程中：复杂算法） * 混合型任务 = 视机器配置和复杂度自测而定 */ @Bean(name = "asyncTaskExecutor") public Thread
springboot线程池超级详解
最新发布
xwnxwn的专栏
07-28 1054
线程，程序执行流的最小执行单位，是行程中的实际运作单位，经常容易和进程这个概念混淆。那么，线程和进程究竟有什么区别呢？首先，进程是一个动态的过程，是一个活动的实体。简单来说，一个应用程序的运行就可以被看做是一个进程，而线程，是运行中的实际的任务执行者。可以说，进程中包含了多个可以同时运行的线程。单线程，顾名思义即是只有一条线程在执行任务。多线程，创建多条线程同时执行任务，这种方式在我们的日常生活中比较常见。但是，在多线程的使用过程中，还有许多需要我们了解的概念。
Java多线程开发系列之Springboot 中异步请求方法的使用
guanshengg的博客
08-17 1872
在过往的后台开发中，我们往往使用java自带的线程或线程池，来进行异步的调用。这对于效果来说没什么，甚至可以让开发人员对底层的状况更清晰，但是对于代码的易读性和可维护性却非常的差...
【http】Keep-alive 知多少？作用？默认时长？
qfzhangwei的专栏
05-27 7257
1 作用： Persistent (or Keep-alive) Connections In HTTP/1.0, the server closes the TCP connection after delivering the response by default (Connection: Close). That is, each TCP connection services onl...
SpringBoot中线程池的使用
JackMa的博客
08-21 2743
上面的异步方法是通过SpringBoot中自动注入的线程池任务执行器实现的，我们并未创建任何线程池。大部分情况下自动注入的线程池不符合实际需求，需要根据实际场景自定义线程池。// 创建线程池任务执行器对象// 设置核心线程数量// 设置最大线程数量// 设置阻塞队列容量// 设置线程空闲时间，默认为 60 秒// 设置是否支持回收核心线程，默认为 false// 设置线程名称前缀，若不设置则根据对象的 beanName 生成。
SpringBoot线程池详解含完整示例（值得珍藏）
01-29
在Spring Boot中，线程池的使用涵盖了多种类型的ExecutorService实现，包括SingleThreadExecutor、FixedThreadPool、CachedThreadPool和ScheduledThreadPool。 1. SingleThreadExecutor：这个线程池仅使用一个线程...
SpringBoot2线程池定义使用方法解析
08-19
"SpringBoot2线程池定义使用方法解析" SpringBoot2线程池定义使用方法解析是指在SpringBoot2框架中定义和使用线程池的方法。线程池是Java中的一种多线程编程模式，用于提高程序的执行效率和响应速度。 SpringBoot2...
[开源项目]可观测、易使用的SpringBoot线程池.pdf
08-09
为解决这些问题，出现了开源项目"可观测、易使用的SpringBoot线程池"，该项目的目标是在不改变Spring Boot线程池核心实现的基础上，提供可视化的监控、简化配置和增强易用性。 首先，该项目并不修改Spring Boot...
SpringBoot 多任务并行+线程池处理的实现
08-27
SpringBoot 多任务并行+线程池处理的实现 SpringBoot 多任务并行+线程池处理是 SpringBoot 框架中的一种高效的并发处理机制。它通过使用线程池来管理多个任务的并行执行，从而提高系统的性能和可扩展性。在本文中，...
SpringBoot使用线程池
热门推荐
Cain的博客
07-05 1万+
SpringBoot使用线程池 软件环境 名称 版本号 jdk 1.8 springboot 2.1.6 maven 3.3.9 1.Java中创建线程池 只会介绍java中线程池的核心类ThreadPoolExecutor，其他用法请自行查询 1.1 ThreadPoolExecutor类介绍 jdk1.8 源码 删减部分内容 package java...
Springboot配置线程池
coderrrrrr的博客
05-02 4355
（1）：核心线程数，指的是核心线程大小，线程池中维护一个最小的线程数量，即使这些线程处于空闲状态，也一直存在池中，除非设置了。（2）：最大线程数，指的是。（3）：空闲线程存活时间，具体说，当线程数大于核心线程数时，空闲线程在等待新任务到达的最大时间，如果超过这个时间还没有任务请求，该空闲线程就会被销毁。（4）：空闲线程存活时间的单位，keepAliveTime的计量单位。枚举类型TimeUnit类。（5）
利用ThreadPoolTaskExecutor创建线程池，并实现数据透传
十一月de肖邦
03-30 3094
1.线程池配置 @Configuration public class ThreadPoolConfig { /** * cpu内核 暂时默认8核 */ private static final int CORE_SIZE = 8; /** * 核心线程数 暂定为I/O密集型 */ private static final int CORE_POOL_SIZE = 2 * CORE_SIZE + 1; /** *
【并发编程】SpringBoot创建线程池的六种方式
C3Stones
03-21 6869
* 优点：可以自定义参数*
spring自定义线程池 逻辑 配置 ThreadPoolTaskExecutor corePoolSize maxPoolSize queueCapacity rejectedExecutionHa
预立数据科技
07-05 2490
spring自定义线程池 逻辑 配置 ThreadPoolTaskExecutor corePoolSize maxPoolSize queueCapacity rejectedExecutionHandler
线程与进程
李晨璐的博客
01-17 536
目录 什么是进程： C#如何操作进程： 什么是线程： 解决的问题： 单线程的问题： 线程10个应用（创建，结束，终止，控制，跨线程访问，并发，线程池） 多线程的应用场景： 什么是进程： 是windows系统中的一个基本概念，他包含着一个运行程序所需要的资源。进程之间是相对独立的，一个进程无法直接访问另一个进程的数据（除非利用分布式计算方式），一个进程运行的失败也不会影响其他进程的...
Springboot自带线程池
weixin_45874214的博客
04-30 6204
骑着蜗牛去旅游
Springboot中使用线程池
qq_39652397的博客
04-26 1283
一、导读 java多线程的使用很多，这里介绍一下springboot中的多线程的使用，使用线程连接池。 二、关键代码 CustomThreadPoolTaskExecutor 类代码 public class CustomThreadPoolTaskExecutor extends ThreadPoolTaskExecutor { private void showThreadPoolInfo(String prefix) { ThreadPoolExecutor thre
springboot线程池使用
08-26
在使用Spring Boot中的线程池服务时，我们可以通过配置ThreadPoolExecutor来创建线程池。Spring Boot框架还提供了@Async注解，使我们能够更方便地将业务逻辑提交到线程池中进行异步执行。下面是使用Spring Boot线程池的步骤： 1. 创建一个Spring Boot工程。 2. 创建Service层的接口和实现类。 3. 创建Controller，并开发一个HTTP服务接口，该接口将调用Service层的服务。 4. 创建线程池的配置类，可以在配置文件中设置线程池的参数，例如核心线程数、最大线程数、线程空闲时间等。 5. 在Service层的方法上添加@Async注解，将这些方法异步化，这样每次调用都会被提交到线程池中异步执行。 6. 可以扩展ThreadPoolTaskExecutor类，在提交任务到线程池的时候观察当前线程池的情况，例如任务的完成情况、线程池的活跃线程数等。 通过以上步骤，我们就可以在Spring Boot中使用线程池来实现异步执行。这样可以提高系统的并发性能和响应速度，同时充分利用系统资源。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [springboot线程池的使用和扩展](https://blog.csdn.net/boling_cavalry/article/details/79120268)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值