整合线程池

已于 2024-08-23 15:33:35 修改
阅读量286 收藏 7
点赞数 4
分类专栏： Spring Boot 3 实战 文章标签： spring boot
于 2024-03-28 16:33:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/idbb98/article/details/137116579
版权
本文介绍了如何在Spring Boot中封装线程池，包括新增application.yml配置、properties类、配置类和服务实现，以实现线程池的统一管理和性能监控。此外，还推荐了两种线程池配置，一种用于常见短任务，另一种针对长耗时任务。最后，解答了Spring线程池与JDK线程池的区别，并讨论了动态调整线程池配置的方法。
摘要由CSDN通过智能技术生成

频繁的创建、销毁线程和线程池，会给系统带来额外的开销。未经池化及统一管理的线程，则会导致系统内线程数上限不可控。随着访问数增加，系统内线程数持续增长，CPU负载逐步提高。极端情况下，甚至可能会导致CPU资源被吃满，整个服务不可用。

封装线程池

新增application.yml配置

这里主要是配置ThreadPoolTastExecutor比较重要的参数

# 定义一个线程池配置
thread:
  # 使用ThreadPoolExecutor作为线程池实现
  poolexecutor:
    core-pool-size: 10          # 线程池的基本大小，核心线程一直存活
    max-pool-size: 20          # 线程池最大大小
    queue-capacity: 200        # 线程池任务队列的容量，任务将队列塞满之后，扩展核心线程，线程总数最多不超过最大线程数
    keep-alive-seconds: 60     # 线程的空闲时间
    thread-name-prefix: thread-pool-executor- # 线程名称的前缀

properties类

这个是为了简化代码，不用@Value一个一个去获取值

@Component
@ConfigurationProperties(prefix = "thread.poolexecutor")
public class ThreadPoolProperties {

    private Integer corePoolSize;
    private Integer maxPoolSize;
    private Integer queueCapacity;
    private Integer keepAliveSeconds;
    private String threadNamePrefix;

		// getter,setter
}

配置类

配置线程池，并将其注入到bean中

// 开启异步支持的配置类
@EnableAsync
// 配置类
@Configuration
public class ThreadPoolConfig {

    // 自动注入线程池属性配置
    @Autowired
    private ThreadPoolProperties threadPoolProperties;

    /**
     * 创建并配置一个线程池任务执行器。
     * 
     * @return Executor 返回配置好的线程池任务执行器实例。
     */
    @Bean(name = "taskExecutor")
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 根据配置设定线程池的核心大小，核心线程一直存活
        executor.setCorePoolSize(threadPoolProperties.getCorePoolSize());
        // 根据配置设定线程池的最大大小
        executor.setMaxPoolSize(threadPoolProperties.getMaxPoolSize());
        // 根据配置设定线程池队列的容量，任务将队列塞满之后，扩展核心线程，线程总数最多不超过最大线程数
        executor.setQueueCapacity(threadPoolProperties.getQueueCapacity());
        // 根据配置设定线程的保持活跃时间
        executor.setKeepAliveSeconds(threadPoolProperties.getKeepAliveSeconds());
        // 设置线程名称前缀
        executor.setThreadNamePrefix(threadPoolProperties.getThreadNamePrefix());
        // 线程池关闭时等待所有任务完成再销毁
        executor.setWaitForTasksToCompleteOnShutdown(true);
        // 设置拒绝执行处理器为CallerRunsPolicy，即调用者运行策略：任务超出线程池容量后，新任务交还主线程处理
        // 当提交的线程填满核心线程数,并且塞满了队列缓冲区,并且超过了最大线程数时就会触发拒绝策略;
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
}

封装Service和service实现类，方便管理

public interface ICustomAsync {
    void doAsync();
}

@Service // 服务组件
public class CustomAsyncImpl implements ICustomAsync {

    private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(CustomAsyncImpl.class); // 初始化日志记录器

    @Override
    @Async("taskExecutor") // 指定使用名为"taskExecutor"的线程池进行异步执行
    public void doAsync() {
        logger.info("=== async start ===");
        logger.info("线程: {}执行代码逻辑", Thread.currentThread().getName());
        logger.info("=== async end ===");
    }
}

测试

@SpringBootTest
public class CustomAsyncTest {

    @Autowired
    private ICustomAsync customAsync;

    @Test
    void doAsyncTests() {
        for (int i = 0; i < 10; i++) { 
            customAsync.doAsync();
        }
    }
}

返回结果：

2024-03-28 10:49:31,326 INFO  [thread-pool-executor-1] c.k.b.s.i.CustomAsyncImpl.(): === async start ===
2024-03-28 10:49:31,327 INFO  [thread-pool-executor-3] c.k.b.s.i.CustomAsyncImpl.(): === async start ===
2024-03-28 10:49:31,328 INFO  [thread-pool-executor-2] c.k.b.s.i.CustomAsyncImpl.(): === async start ===
2024-03-28 10:49:31,330 INFO  [thread-pool-executor-5] c.k.b.s.i.CustomAsyncImpl.(): === async start ===
2024-03-28 10:49:31,332 INFO  [thread-pool-executor-5] c.k.b.s.i.CustomAsyncImpl.(): 线程:thread-pool-executor-5执行代码逻辑
2024-03-28 10:49:31,332 INFO  [thread-pool-executor-5] c.k.b.s.i.CustomAsyncImpl.(): === async end ===
2024-03-28 10:49:31,331 INFO  [thread-pool-executor-2] c.k.b.s.i.CustomAsyncImpl.(): 线程:thread-pool-executor-2执行代码逻辑
2024-03-28 10:49:31,332 INFO  [thread-pool-executor-2] c.k.b.s.i.CustomAsyncImpl.(): === async end ===
2024-03-28 10:49:31,332 INFO  [thread-pool-executor-3] c.k.b.s.i.CustomAsyncImpl.(): 线程:thread-pool-executor-3执行代码逻辑
2024-03-28 10:49:31,333 INFO  [thread-pool-executor-3] c.k.b.s.i.CustomAsyncImpl.(): === async end ===
2024-03-28 10:49:31,344 INFO  [thread-pool-executor-4] c.k.b.s.i.CustomAsyncImpl.(): === async start ===
2024-03-28 10:49:31,346 INFO  [thread-pool-executor-4] c.k.b.s.i.CustomAsyncImpl.(): 线程:thread-pool-executor-4执行代码逻辑
2024-03-28 10:49:31,350 INFO  [thread-pool-executor-4] c.k.b.s.i.CustomAsyncImpl.(): === async end ===
2024-03-28 10:49:31,351 INFO  [thread-pool-executor-1] c.k.b.s.i.CustomAsyncImpl.(): 线程:thread-pool-executor-1执行代码逻辑
2024-03-28 10:49:31,354 INFO  [thread-pool-executor-1] c.k.b.s.i.CustomAsyncImpl.(): === async end ===
2024-03-28 10:49:31,357 INFO  [thread-pool-executor-6] c.k.b.s.i.CustomAsyncImpl.(): === async start ===
2024-03-28 10:49:31,358 INFO  [thread-pool-executor-6] c.k.b.s.i.CustomAsyncImpl.(): 线程:thread-pool-executor-6执行代码逻辑
2024-03-28 10:49:31,359 INFO  [thread-pool-executor-6] c.k.b.s.i.CustomAsyncImpl.(): === async end ===
2024-03-28 10:49:31,362 INFO  [thread-pool-executor-7] c.k.b.s.i.CustomAsyncImpl.(): === async start ===
2024-03-28 10:49:31,362 INFO  [thread-pool-executor-8] c.k.b.s.i.CustomAsyncImpl.(): === async start ===
2024-03-28 10:49:31,362 INFO  [thread-pool-executor-7] c.k.b.s.i.CustomAsyncImpl.(): 线程:thread-pool-executor-7执行代码逻辑
2024-03-28 10:49:31,362 INFO  [thread-pool-executor-8] c.k.b.s.i.CustomAsyncImpl.(): 线程:thread-pool-executor-8执行代码逻辑
2024-03-28 10:49:31,362 INFO  [thread-pool-executor-7] c.k.b.s.i.CustomAsyncImpl.(): === async end ===
2024-03-28 10:49:31,362 INFO  [thread-pool-executor-8] c.k.b.s.i.CustomAsyncImpl.(): === async end ===
2024-03-28 10:49:31,364 INFO  [thread-pool-executor-9] c.k.b.s.i.CustomAsyncImpl.(): === async start ===
2024-03-28 10:49:31,364 INFO  [thread-pool-executor-9] c.k.b.s.i.CustomAsyncImpl.(): 线程:thread-pool-executor-9执行代码逻辑
2024-03-28 10:49:31,364 INFO  [thread-pool-executor-9] c.k.b.s.i.CustomAsyncImpl.(): === async end ===
2024-03-28 10:49:31,367 INFO  [thread-pool-executor-10] c.k.b.s.i.CustomAsyncImpl.(): === async start ===
2024-03-28 10:49:31,367 INFO  [thread-pool-executor-10] c.k.b.s.i.CustomAsyncImpl.(): 线程:thread-pool-executor-10执行代码逻辑
2024-03-28 10:49:31,367 INFO  [thread-pool-executor-10] c.k.b.s.i.CustomAsyncImpl.(): === async end ===

可以发现，该方法使用了线程池.

扩展：打印线程池情况，占用性能

  • 编写 VisibleThreadPoolTaskExecutor 继承 ThreadPoolTaskExecutor 类
/**
 * 可见的线程池任务执行器，继承自ThreadPoolTaskExecutor，增强了线程池执行任务时的日志记录功能。
 */
public class VisibleThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {

    private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory
            .getLogger(VisibleThreadPoolTaskExecutor.class);

    /**
     * 打印线程池当前状态的方法。
     * 
     * @param method 当前调用的方法名，用于日志标记。
     */
    private void log(String method) {
        ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();

        // 打印线程池关键信息到日志，包括线程名前缀、调用方法、任务总数、完成任务数、活跃线程数和队列长度。
        logger.info("线程池：{}, 执行方法：{},任务数量 [{}], 完成任务数量 [{}], 活跃线程数 [{}], 队列长度 [{}]",
                this.getThreadNamePrefix(),
                method,
                threadPoolExecutor.getTaskCount(),
                threadPoolExecutor.getCompletedTaskCount(),
                threadPoolExecutor.getActiveCount(),
                threadPoolExecutor.getQueue().size());
    }

    /**
     * 重写execute方法，记录执行日志。
     * 
     * @param task 将要执行的任务对象。
     */
    @Override
    public void execute(Runnable task) {
        log("execute");
        super.execute(task);
    }

    /**
     * 重写带启动超时的execute方法，记录执行日志。
     * 
     * @param task         将要执行的任务对象。
     * @param startTimeout 启动任务的超时时间。
     */
    @Override
    public void execute(Runnable task, long startTimeout) {
        log("execute");
        super.execute(task, startTimeout);
    }

    /**
     * 重写submit方法，记录执行日志。
     * 
     * @param task 将要提交的任务对象。
     * @return 返回Future对象，代表异步执行的结果。
     */
    @Override
    public Future<?> submit(Runnable task) {
        log("submit");
        return super.submit(task);
    }

    /**
     * 重写submit方法，记录执行日志。
     * 
     * @param task 将要提交的带返回值的任务对象。
     * @param <T>  返回值的类型。
     * @return 返回Future对象，代表异步执行的结果。
     */
    @Override
    public <T> Future<T> submit(Callable<T> task) {
        log("submit");
        return super.submit(task);
    }

    /**
     * 重写submitListenable方法，记录执行日志。
     * 
     * @param task 将要提交的任务对象。
     * @return 返回ListenableFuture对象，代表异步执行的结果。
     */
    @Override
    public ListenableFuture<?> submitListenable(Runnable task) {
        log("submitListenable");
        return super.submitListenable(task);
    }

    /**
     * 重写submitListenable方法，记录执行日志。
     * 
     * @param task 将要提交的带返回值的任务对象。
     * @param <T>  返回值的类型。
     * @return 返回ListenableFuture对象，代表异步执行的结果。
     */
    @Override
    public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
        log("submitListenable");
        return super.submitListenable(task);
    }
}
  • 重新编写线程池配置类
// 开启异步支持的配置类
@EnableAsync
// 配置类
@Configuration
public class ThreadPoolConfig {

    // 自动注入线程池属性配置
    @Autowired
    private ThreadPoolProperties threadPoolProperties;

    @Bean(name = "visibleTaskExecutor")
    public Executor visible() {
        // 使用VisibleThreadPoolTaskExecutor作为类
        ThreadPoolTaskExecutor executor = new VisibleThreadPoolTaskExecutor();
        executor.setCorePoolSize(threadPoolProperties.getCorePoolSize());
        executor.setMaxPoolSize(threadPoolProperties.getMaxPoolSize());
        executor.setQueueCapacity(threadPoolProperties.getQueueCapacity());
        executor.setKeepAliveSeconds(threadPoolProperties.getKeepAliveSeconds());
        executor.setThreadNamePrefix(threadPoolProperties.getThreadNamePrefix());
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }

    /**
     * 创建并配置一个线程池任务执行器。
     * 
     * @return Executor 返回配置好的线程池任务执行器实例。
     */
    @Bean(name = "taskExecutor")
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 根据配置设定线程池的核心大小
        executor.setCorePoolSize(threadPoolProperties.getCorePoolSize());
        // 根据配置设定线程池的最大大小
        executor.setMaxPoolSize(threadPoolProperties.getMaxPoolSize());
        // 根据配置设定线程池队列的容量
        executor.setQueueCapacity(threadPoolProperties.getQueueCapacity());
        // 根据配置设定线程的保持活跃时间
        executor.setKeepAliveSeconds(threadPoolProperties.getKeepAliveSeconds());
        // 设置线程名称前缀
        executor.setThreadNamePrefix(threadPoolProperties.getThreadNamePrefix());
        // 线程池关闭时等待所有任务完成再销毁
        executor.setWaitForTasksToCompleteOnShutdown(true);
        // 设置拒绝执行处理器为CallerRunsPolicy，即调用者运行策略：任务超出线程池容量后，新任务交还主线程处理
        // 当提交的线程填满核心线程数,并且塞满了队列缓冲区,并且超过了最大线程数时就会触发拒绝策略;
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }

}
  • service和实现类也重新编写
void visibleAsync();

/**
* 可视化，可以打印线程池情况
*/
@Override
@Async("visibleTaskExecutor")
public void visibleAsync() {
    logger.info("=== async start ===");
    logger.info("线程: {}执行代码逻辑", Thread.currentThread().getName());
    logger.info("=== async end ===");
}
  • 测试
@SpringBootTest
public class CustomAsyncTest {

    @Autowired
    private ICustomAsync customAsync;

    @Test
    void visibleAsyncTests() {
        for (int i = 0; i < 20; i++) {
            customAsync.visibleAsync();
        }
    }
}
  • 返回结果
2024-03-28 11:23:05,406 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [0], 完成任务数量 [0], 活跃线程数 [0], 队列长度 [0]
2024-03-28 11:23:05,407 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [1], 完成任务数量 [0], 活跃线程数 [1], 队列长度 [0]
2024-03-28 11:23:05,407 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [2], 完成任务数量 [0], 活跃线程数 [2], 队列长度 [0]
2024-03-28 11:23:05,408 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [3], 完成任务数量 [0], 活跃线程数 [3], 队列长度 [0]
2024-03-28 11:23:05,408 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [4], 完成任务数量 [0], 活跃线程数 [4], 队列长度 [0]
2024-03-28 11:23:05,409 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [5], 完成任务数量 [0], 活跃线程数 [5], 队列长度 [0]
2024-03-28 11:23:05,409 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [6], 完成任务数量 [0], 活跃线程数 [6], 队列长度 [0]
2024-03-28 11:23:05,409 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [7], 完成任务数量 [0], 活跃线程数 [7], 队列长度 [0]
2024-03-28 11:23:05,409 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [8], 完成任务数量 [0], 活跃线程数 [8], 队列长度 [0]
2024-03-28 11:23:05,409 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [9], 完成任务数量 [0], 活跃线程数 [9], 队列长度 [0]
2024-03-28 11:23:05,414 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [10], 完成任务数量 [0], 活跃线程数 [10], 队列长度 [0]
2024-03-28 11:23:05,415 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [11], 完成任务数量 [0], 活跃线程数 [10], 队列长度 [1]
2024-03-28 11:23:05,415 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [12], 完成任务数量 [0], 活跃线程数 [10], 队列长度 [2]
2024-03-28 11:23:05,416 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [13], 完成任务数量 [0], 活跃线程数 [10], 队列长度 [3]
2024-03-28 11:23:05,417 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [14], 完成任务数量 [0], 活跃线程数 [10], 队列长度 [4]
2024-03-28 11:23:05,417 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [15], 完成任务数量 [0], 活跃线程数 [10], 队列长度 [5]
2024-03-28 11:23:05,423 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [16], 完成任务数量 [0], 活跃线程数 [10], 队列长度 [6]
2024-03-28 11:23:05,425 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [17], 完成任务数量 [0], 活跃线程数 [10], 队列长度 [7]
2024-03-28 11:23:05,427 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [18], 完成任务数量 [0], 活跃线程数 [10], 队列长度 [8]
2024-03-28 11:23:05,430 INFO  [main] c.k.b.c.VisibleThreadPoolTaskExecutor.(): 线程池：thread-pool-executor-, 执行方法：submit,任务数量 [19], 完成任务数量 [0], 活跃线程数 [10], 队列长度 [9]
2024-03-28 11:23:05,431 INFO  [thread-pool-executor-1] c.k.b.s.i.CustomAsyncImpl.(): === async start ===
2024-03-28 11:23:05,432 INFO  [thread-pool-executor-1] c.k.b.s.i.CustomAsyncImpl.(): 线程: thread-pool-executor-1执行代码逻辑
2024-03-28 11:23:05,432 INFO  [thread-pool-executor-1] c.k.b.s.i.CustomAsyncImpl.(): === async end ===
2024-03-28 11:23:05,433 INFO  [thread-pool-executor-1] c.k.b.s.i.CustomAsyncImpl.(): === async start ===
2024-03-28 11:23:05,435 INFO  [thread-pool-executor-1] c.k.b.s.i.CustomAsyncImpl.(): 线程: thread-pool-executor-1执行代码逻辑
2024-03-28 11:23:05,441 INFO  [thread-pool-executor-1] c.k.b.s.i.CustomAsyncImpl.(): === async end ===
2024-03-28 11:23:05,441 INFO  [thread-pool-executor-1] c.k.b.s.i.CustomAsyncImpl.(): === async start ===
2024-03-28 11:23:05,441 INFO  [thread-pool-executor-1] c.k.b.s.i.CustomAsyncImpl.(): 线程: thread-pool-executor-1执行代码逻辑
......

每次执行的时候，都会打印对应的线程池情况了

线程池配置推荐

常用线程池

commonTaskExecutor 该线程池核心线程20，缓存队列60，最大线程100。

核心线程满载之后，新任务会先放到缓存队列中。适用于触发频率高、耗时短的任务。因为这种任务会迅速释放掉核心线程，然后继续消化缓存队列中的任务。这样既能保证队列中任务不会等太久，也降低了频繁创建销毁线程的资源开销。

长耗时线程池

对于耗时长的任务，如果使用常用线程池处理，会存在耗时长任务逐渐打满线程池负载，而触发频率高、耗时短的任务没有空闲线程可用的可能性。因此有必要单独为耗时长的任务配置一个线程池。

expensiveTaskExecutor 该线程池核心线程20，缓存队列0，最大线程100。

核心线程满载之后，会立即开启新线程。适用于触发频率低、耗时长的任务。因为这类任务占用单个线程时间长，缓存队列为0，有利于缩短任务平均执行时间。

注：以上两个线程池配置，是基于网络模块自身业务特征，在实践中总结出来的，并不完全适用于其他模块，请根据各自模块业务特征进行微调。

FAQ

Spring的线程池ThreadPoolTaskExecutor，和JDK自带线程池ThreadPoolExecutor的区别是什么？

ThreadPoolTaskExecutor在ThreadPoolExecutor的基础上进行了一层封装，增加了submitListenable方法。

而submitListenable方法返回的ListenableFuture接口对象，可以用来添加线程执行完毕后成功和失败的回调方法。

与Future.get()方法相比，通过回调的方式，不会阻塞主线程，线程执行结果或抛出的异常通过回调函数异步处理。

示例代码如下：

final ListenableFuture<String> listenableFuture = threadPoolTaskExecutor
    .submitListenable(() -> {
    	TimeUnit.SECONDS.sleep(2);
    	return "result";
	});
listenableFuture.addCallback(data -> log.info(data), e -> log.error(e.getMessage(), e));

是否有办法动态调整线程池配置？

可以将线程池的三个核心参数corePoolSize、queueCapacity、maxPoolSize，配置到配置中心中，项目内线程池从配置中心中取这个配置。

我来整一篇
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
springboot整合线程池
呆萌很的博客
10-25 244
springboot整合线程池
spring boot整合线程池
doubiy的博客
04-16 2799
多线程在项目中运用的很多，比如告警消息的发送，需要将告警信息推送到运维人员的微信、邮件、短信等等，电商项目提交订单需要查询商品基础信息、库存、优惠信息、优惠券、用户积分、收货地址、快递信息等等；其中涉及到的流程比较长，如果采用单线程的方式总计耗时将是所有流程的时间的总和；采用多线程的方式最好的状态是最长流程的时间，如果这些流程有依赖关系则可以采用CompletableFuture进行编排；因此对于接口响应时长有要求的业务多线程的运用必不可少。 一般来说一个项目里面有一个线程池就够了，需要用到多线程的地方使用
SpringBoot 整合线程池
kfashfasf的博客
08-26 241
分为三步启动类加注解在方法上加注解创建线程池配置类。
springboot 项目 整合 线程池
m0_57850369的博客
01-26 404
【代码】springboot 项目 整合 线程池。
线程池详解+springboot整合线程池（超级详细简洁代码可直接执行）
热门推荐
qq_40595922的博客
10-19 1万+
一、概念 与数据库连接池的原理类似，线程池就是将多个线程对象放入一个池子里面，之后从该池子中获取、实用和回收线程。有两点需要明确。1. 每一个线程，在一段时间内只能执行一个任务。2. 线程池中的各个线程是可以重复使用的。 二、线程池的创建方式 Executors.newSingleThreadExecutor() 创建只有一个线程的线程池。其底层源码如下： public static ExecutorService newSingleThreadExecutor() { re...
springboot 整合线程池
请叫我猿叔叔的博客
10-13 8787
一. 简介 二. 代码 2.1 线程池配置类 package com.yzx.caasscs.configuration.thread; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.sp...
springboot 整合线程池（包涵各参数设置说明）
weixin_39388918的博客
08-01 1万+
正文 先上结构图 代码从上往下 ThreadPoolConfig package com.threadpool.demo.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.spri...
SpringBoot 2.x 整合线程池——ThreadPoolTaskExecutor
weixin_43491745的博客
07-29 956
SpringBoot整合ThreadPoolTaskExecutor 1. SpringBoot对线程池的自动装载2. 自定义线程池2.1 根据业务配置不同的线程池2.2 如何使用连接池2.3 如何获取任务的返回值2.4 Runnable异常处理彩蛋——Future\使用lambda表达式彩蛋——若自定义实现线程池，如何获取到各个任务的结果 JAVA && Spring && SpringBoot2.x学习目录 我们在JDK中，可以使用ThreadPoolExecutor提
Springboot使用@Async整合线程池
乐于探索,乐于奉献,追求极致,向往生活
08-17 4742
前言介绍 开篇咱们先来聊聊线程池这个概念，或者说为什么要使用线程池；简言之，充分利用cpu资源，提高程序执行时间，但是相反，线程池异常提示、主线程和子线程事务问题也是显而易见的。那么@Async这个注解又是什么做用呢？其实就是标识方法为异步任务的一个注解，默认会自己维护一个线程池(存在弊端)，利用子线程去执行任务；那么如果把这两者结合的话，线程池+Async又会有什么效果呢！ 循序渐进 提到线程池，可以采用Executors提供四种线程池下，使用某些特性的场景下，还是不错的(简便省事)，当然此篇文章就不进行
springboot如何整合线程池
04-30
在Spring Boot中，我们可以通过在配置类中定义一个线程池的Bean来整合线程池。 首先，我们需要在pom.xml文件中添加以下依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-web ...
@Async整合线程池数量
09-02
因此，根据提供的引用内容，我们无法确定@Async整合线程池的具体数量。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_title] - *1* *3* [SpringBoot 整合线程池(搭配...
springboot整合线程池的例子
05-02
以下是一个使用SpringBoot整合线程池的例子： 1. 在pom.xml文件中添加以下依赖： ``` <groupId>org.springframework.boot <artifactId>spring-boot-starter-web <groupId>org.springframework.boot ...
springboot整合线程池的案例
05-01
好的，以下是一个简单的Spring Boot整合线程池的案例： 1. 在 pom.xml 文件中添加如下依赖： ``` <groupId>org.springframework.boot <artifactId>spring-boot-starter-web <groupId>org.springframework....
Spring boot启动过程详解
chyohn的博客
09-05 1244
本篇主要介绍spring boot在启动过程中都做了哪些工作，重点介绍在spring容器ApplicationContext刷新前都做了哪些准备，本篇以源码解释为主，示例为辅进行梳理其过程。Spring boot整个启动过程分为3部分，分别是1.准备环境配置，2. 准备Spring容器并刷新容器，3. 容器刷新后处理。每个部分又有如下图所示的步骤，本篇详细讲解这些步骤。
使用Spring Boot集成Spring Data JPA和单例模式构建库存管理系统
心猿意码
09-09 695
库存管理系统的核心在于管理产品和其数量。java深色版本56@Entity8 @Id1315}
【编程基础知识】Spring Boot概述(主要特点、核心组件及其优势)
Dylaniou的博客
09-09 426
Spring Boot是一个开源Java框架,由Pivotal团队（现为VMware的一部分）开发，用于简化Spring应用程序创建和部署过程。旨在让开发者更快速地启动和运行新的Spring项目，通过提供一系列默认配置来减少开发者的配置工作。
Spring Boot项目中如何解决循环依赖
最新发布
心猿意码
09-09 985
在Spring Boot项目中，循环依赖是一个常见的问题，尤其是在构建复杂的微服务架构时。当两个或多个Bean相互持有对方的引用时，就会形成循环依赖。Spring框架通过不同的机制来解决这个问题，以保证应用程序能够正确地启动并运行。下面我们将探讨几种处理循环依赖的方法，同时也深入了解一下Spring是如何处理Bean的初始化过程的。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值