Springboot实现多线程及线程池监控

本文介绍线程池的优点及如何在Spring Boot中配置线程池,并实现对线程池状态的实时监控。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

线程池的优点

  1. 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗
  2. 提高响应速度。当任务到达时,任务可以不需要等到线程创建就能立即执行
  3. 可以对线程做统一管理。

1.配置线程池

修改配置文件

# 异步线程配置
# 配置核心线程数
async:
  executor:
    thread:
      core_pool_size: 5 # 配置核心线程数
      max_pool_size: 5 # 配置最大线程数
      queue_capacity: 99999 # 配置队列大小
      name:
        prefix: async-service- # 配置线程池中的线程的名称前

线程池配置类

package com.bt.springboot.config;

import com.bt.springboot.task.ThreadPoolMonitor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author zkx
 * @Date 2022/12/6 21:42
 */
@Slf4j
@Configuration
@EnableAsync
public class ExecutorConfig {

	@Value("${async.executor.thread.core_pool_size}")
	private int corePoolSize;
	@Value("${async.executor.thread.max_pool_size}")
	private int maxPoolSize;
	@Value("${async.executor.thread.queue_capacity}")
	private int queueCapacity;
	@Value("${async.executor.thread.name.prefix}")
	private String namePrefix;

	@Bean(name = "asyncServiceExecutor")
	public Executor asyncServiceExecutor() {
		log.info("start asyncServiceExecutor");
		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
		//配置核心线程数
		executor.setCorePoolSize(corePoolSize);
		//配置最大线程数
		executor.setMaxPoolSize(maxPoolSize);
		//配置队列大小
		executor.setQueueCapacity(queueCapacity);
		//配置线程池中的线程的名称前缀
		executor.setThreadNamePrefix(namePrefix);

		// rejection-policy:当pool已经达到max size的时候,如何处理新任务
		// CALLER_RUNS:不在新线程中执行任务,而是有调用者所在的线程来执行
		executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
		//执行初始化
		executor.initialize();
		return executor;
	}
}


2.监控类

package com.bt.springboot.task;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;

import java.util.concurrent.ThreadPoolExecutor;

/**
 * @Author: ChenBin
 */
@Slf4j
@Component
public class ThreadPoolMonitor extends ThreadPoolTaskExecutor {

	@Value("${async.executor.thread.name.prefix}")
	private String namePrefix;

	@Scheduled(cron = "0/1 * * * * ? ")
	private void showThreadPoolInfo() {
		ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();
		if (namePrefix.equals(this.getThreadNamePrefix())){
			log.info("{} taskCount [{}], completedTaskCount [{}], activeCount [{}], queueSize [{}]",
					this.getThreadNamePrefix(),
					threadPoolExecutor.getTaskCount(),
					threadPoolExecutor.getCompletedTaskCount(),
					threadPoolExecutor.getActiveCount(),
					threadPoolExecutor.getQueue().size());
		}
	}
}

开启定时任务
在这里插入图片描述


3.修改线程池配置类

ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
修改为ThreadPoolTaskExecutor executor = new ThreadPoolMonitor();


4.测试相关类

AsyncService

package com.bt.springboot.async;

/**
 * @author zkx
 * @Date 2022/12/6 21:47
 */
public interface AsyncService {

	/**
	 * 执行异步任务
	 * 可以根据需求,自己加参数拟定,我这里就做个测试演示
	 */
	void executeAsync();
}

AsyncServiceImpl

package com.bt.springboot.async.impl;

import com.bt.springboot.async.AsyncService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

/**
 * @author zkx
 * @Date 2022/12/6 21:48
 */
@Slf4j
@Service
public class AsyncServiceImpl implements AsyncService {



	@Override
	@Async("asyncServiceExecutor")
	public void executeAsync() {
		int i = 5;
		while(i > 0){
			i--;
			log.info("execute task");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
				Thread.currentThread().interrupt();
			}
		}
	}
}

AsyncController

package com.bt.springboot.web.controller;

import com.bt.springboot.async.AsyncService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author zkx
 * @Date 2022/12/9 17:38
 */
@RestController
public class AsyncController {

	@Autowired
	private AsyncService asyncService;

	@GetMapping("/asyncTask")
	public void asyncTask(){
		asyncService.executeAsync();
	}
}

5.启动

1.执行任务前

2.执行任务
在这里插入图片描述
3.任务完成
在这里插入图片描述

<think>好的,我现在需要帮用户解决在Spring Boot项目中配置线程池实现多线程操作的问题。首先,我得回忆一下Spring Boot配置线程池的常见方法。根据用户提供的引用内容,他们提到了配置类和使用注解的方式,比如@Async和@EnableAsync。 首先,用户可能需要一个具体的步骤指南,从添加依赖开始。不过引用里提到添加依赖,但没有具体说明是哪个依赖。通常Spring Boot已经内置了线程池支持,可能不需要额外依赖,除非使用特定的库。不过需要确认,比如Spring Boot Starter Web或者Spring Boot Starter Async?可能需要查阅资料,但根据引用内容,用户可能已经添加了相关依赖,所以接下来是配置类。 然后,创建配置类,使用@Configuration和@EnableAsync来启用异步支持。配置线程池的参数,比如核心线程数、最大线程数、队列容量等。这里需要确保使用正确的Bean名称,比如taskExecutor,因为@Async默认会使用这个名称的线程池。 接下来是编写异步任务,使用@Service标注类,并在方法上使用@Async。需要提醒用户注意@Async的局限性,比如同一个类内调用异步方法不会生效,必须通过代理对象调用。 然后给出一个使用示例,比如在Controller中注入Service并调用异步方法。这部分代码需要简单明了,让用户容易理解。 最后,注意事项部分需要包括线程池参数调优建议,异常处理,以及不同场景下的线程池配置。比如IO密集型和CPU密集型任务的区别,使用自定义线程池名称的方法等。 用户可能还会有疑问,比如如何监控线程池状态,或者如何处理异步任务的返回值。不过当前问题主要是配置和使用方法,所以这些高级内容可能放在后续问题中。 现在需要确保步骤清晰,代码示例正确,并且符合用户提供的引用内容中的方法。同时要避免错误,比如线程池配置参数是否合理,Bean的名称是否正确。最后生成相关问题,帮助用户深入理解。</think>在Spring Boot中配置和使用线程池实现多线程操作,可以通过以下步骤完成: ### 一、添加依赖(非必须) Spring Boot默认包含线程池支持,若需异步功能需引入: ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-async</artifactId> </dependency> ``` ### 二、创建线程池配置类 ```java @Configuration @EnableAsync public class ThreadPoolConfig { @Bean("taskExecutor") public Executor taskExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(5); // 核心线程数[^3] executor.setMaxPoolSize(10); // 最大线程数 executor.setQueueCapacity(100); // 队列容量 executor.setKeepAliveSeconds(60); // 空闲线程存活时间 executor.setThreadNamePrefix("async-"); // 线程名前缀 executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); executor.initialize(); return executor; } } ``` ### 三、编写异步任务 ```java @Service public class AsyncService { @Async("taskExecutor") // 指定使用配置的线程池[^2] public void asyncProcess(String data) { // 模拟耗时操作 try { Thread.sleep(2000); System.out.println("处理数据:" + data + " 线程:" + Thread.currentThread().getName()); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } ``` ### 四、使用示例 ```java @RestController public class DemoController { @Autowired private AsyncService asyncService; @GetMapping("/start-task") public String startTask() { for(int i=0; i<10; i++){ asyncService.asyncProcess("任务" + i); } return "任务已提交"; } } ``` ### 五、关键配置参数说明 | 参数 | 说明 | |---------------------|----------------------------------------------------------------------| | corePoolSize | 核心线程数,默认保持活动的线程数 | | maxPoolSize | 最大线程数,队列满后允许创建的最大线程数[^3] | | queueCapacity | 任务队列容量,缓冲执行任务的队列大小 | | keepAliveSeconds | 非核心线程空闲存活时间 | | threadNamePrefix | 线程名前缀,方便日志追踪 | | rejectionPolicy | 拒绝策略(AbortPolicy/CallerRunsPolicy等) | ### 六、注意事项 1. **参数调优**:根据业务类型调整参数,IO密集型任务可增大核心线程数,CPU密集型任务不宜设置过大线程数 2. **异常处理**:异步方法建议自行捕获异常,或实现`AsyncUncaughtExceptionHandler` 3. **@Async限制**: - 需通过代理对象调用(同类内部调用无效) - 方法需定义为public - 返回值为void或Future类型 ### 七、扩展用法 ```java // 带返回值的异步任务 @Async public Future<String> asyncWithResult() { return new AsyncResult<>("处理完成"); } // 自定义线程池 @Async("customExecutor") public void customPoolTask() { ... } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值