java使用线程池异步执行多个方法并最终合并返回数据

最新推荐文章于 2024-10-20 09:00:00 发布

susu1083018911

最新推荐文章于 2024-10-20 09:00:00 发布

阅读量769

点赞数 2

文章标签： java 开发语言

本文链接：https://blog.csdn.net/susu1083018911/article/details/137497423

版权

本文介绍了如何在SpringBoot项目中配置ThreadPoolConfig，根据服务器CPU核心数动态设置线程池参数，并利用CompletableFuture实现异步任务的并发执行。展示了如何使用ThreadPoolTaskExecutor进行线程管理和控制线程池策略。

摘要由CSDN通过智能技术生成

配置线程池

@Configuration
public class ThreadPoolConfig {
    // 核心线程池大小
    private int corePoolSize = 50;

    // 最大可创建的线程数
    private int maxPoolSize = 200;

    // 队列最大长度
    private int queueCapacity = 1000;

    // 线程池维护线程所允许的空闲时间
    private int keepAliveSeconds = 300;

    @Bean(name = "threadPoolTaskExecutor")
    public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
        //获取服务器CPU核心数
        int cpuCoreNumber = Runtime.getRuntime().availableProcessors();
        log.info("当前服务器CPU核心数为{},开始创建消息处理线程池，核心线程池数量为{},最大线程数量{},线程池的队列容量为{}", cpuCoreNumber, cpuCoreNumber, cpuCoreNumber*2, cpuCoreNumber*5);

        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //核心线程池数量，方法: 返回可用处理器的Java虚拟机的数量。
        executor.setCorePoolSize(cpuCoreNumber);
        //最大线程数量
        executor.setMaxPoolSize(cpuCoreNumber*2);
        //线程池的队列容量
        executor.setQueueCapacity(cpuCoreNumber*5);
        // 线程池维护线程所允许的空闲时间
        executor.setKeepAliveSeconds(keepAliveSeconds);
        //线程名称的前缀（可以考虑将消息发送和消息处理分为不同的线程池）
        executor.setThreadNamePrefix("异步处理-");
        // 线程池对拒绝任务(无线程可用)的处理策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
}

使用：

@Slf4j
public class TestServiceImpl implements TestService{
@Autowired
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;

   public static void main(String[] args) {
   		// 返回对象自己定义
        Map<String, Object> resultMap = new HashMap<>();
		
		 CompletableFuture<Void> test1 = CompletableFuture.runAsync(() -> {
            test01 (resultMap);
        }, threadPoolTaskExecutor);

        CompletableFuture<Void> test2  = CompletableFuture.runAsync(() -> {
            test02 (resultMap);
        }, threadPoolTaskExecutor);

        CompletableFuture<Void> test3  = CompletableFuture.runAsync(() -> {
            test103(resultMap);
        }, threadPoolTaskExecutor);
        // 
        CompletableFuture.allOf(test1, test2,test3 ).join();
		resultMap .foreach((key,value) ->{
			System.out.println(key);
			System.out.println(value.toStrung());
		});    
	}

	/**
     * test01
     */
	private void test01(Map<String, Object> resultMap){
		/**
     	* 逻辑处理
     	*/
   		resultMap.put("test01","这是方法一");  
	}

	/**
     * test02
     */
	private void test02(Map<String, Object> resultMap){
		/**
     	* 逻辑处理
     	*/
      	resultMap.put("test02","这是方法二");  
	}

	/**
     * test03
     */
	private void test03(Map<String, Object> resultMap){
		/**
     	* 逻辑处理
     	*/
     	 resultMap.put("test03","这是方法三");  
	}
}

补充知识：

CompletableFuture的常用方法