文章目录
Spring Boot 中多线程工具类的配置与使用：基于 YAML 配置文件
在现代软件开发中，多线程编程是提高系统性能和并发处理能力的重要手段。Spring Boot 作为一款流行的 Java 开发框架，提供了强大的多线程支持。本文将详细介绍如何在 Spring Boot 中结合 YAML 配置文件，实现一个灵活、可配置的多线程工具类。
1. 为什么需要多线程工具类？
在多线程编程中，直接使用 Thread 或 ExecutorService 可能会导致以下问题：
- 资源浪费：频繁创建和销毁线程会消耗大量系统资源。
- 难以管理：线程的生命周期和状态难以监控和维护。
- 配置不灵活：线程池的参数（如核心线程数、队列容量等）硬编码在代码中，难以动态调整。
通过封装一个多线程工具类，并结合 YAML 配置文件，可以解决上述问题，使多线程编程更加高效和灵活。
2. 实现步骤
2.1 添加依赖
在 pom.xml 中添加 Spring Boot 的依赖：
<dependencies>
<!-- Spring Boot Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!-- Spring Boot Configuration Processor -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
2.2 配置线程池参数
在 application.yml 中定义线程池的配置参数：
thread-pool:
core-pool-size: 10 # 核心线程数
max-pool-size: 20 # 最大线程数
queue-capacity: 100 # 任务队列容量
keep-alive-time: 60 # 线程空闲时间（秒）
thread-name-prefix: "custom-thread-" # 线程名称前缀
2.3 创建配置类
通过 @ConfigurationProperties 注解将 YAML 文件中的配置映射到 Java 类中：
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "thread-pool")
public class ThreadPoolProperties {
private int corePoolSize;
private int maxPoolSize;
private int queueCapacity;
private long keepAliveTime;
private String threadNamePrefix;
// Getters and Setters
public int getCorePoolSize() {
return corePoolSize;
}
public void setCorePoolSize(int corePoolSize) {
this.corePoolSize = corePoolSize;
}
public int getMaxPoolSize() {
return maxPoolSize;
}
public void setMaxPoolSize(int maxPoolSize) {
this.maxPoolSize = maxPoolSize;
}
public int getQueueCapacity() {
return queueCapacity;
}
public void setQueueCapacity(int queueCapacity) {
this.queueCapacity = queueCapacity;
}
public long getKeepAliveTime() {
return keepAliveTime;
}
public void setKeepAliveTime(long keepAliveTime) {
this.keepAliveTime = keepAliveTime;
}
public String getThreadNamePrefix() {
return threadNamePrefix;
}
public void setThreadNamePrefix(String threadNamePrefix) {
this.threadNamePrefix = threadNamePrefix;
}
}
2.4 创建线程池工具类
在工具类中注入 ThreadPoolProperties，并根据配置创建线程池：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.concurrent.*;
@Component
public class ThreadPoolUtil {
private ThreadPoolExecutor threadPool;
@Autowired
private ThreadPoolProperties threadPoolProperties;
/**
* 初始化线程池
*/
@PostConstruct
public void init() {
threadPool = new ThreadPoolExecutor(
threadPoolProperties.getCorePoolSize(),
threadPoolProperties.getMaxPoolSize(),
threadPoolProperties.getKeepAliveTime(),
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(threadPoolProperties.getQueueCapacity()),
new ThreadFactory() {
private final AtomicInteger threadNumber = new AtomicInteger(1);
@Override
public Thread newThread(Runnable r) {
return new Thread(r, threadPoolProperties.getThreadNamePrefix() + threadNumber.getAndIncrement());
}
},
new ThreadPoolExecutor.AbortPolicy() // 拒绝策略：直接抛出异常
);
}
/**
* 提交任务（Runnable）
*
* @param task 任务
*/
public void execute(Runnable task) {
threadPool.execute(task);
}
/**
* 提交任务（Callable）
*
* @param task 任务
* @param <T> 返回值类型
* @return Future 对象
*/
public <T> Future<T> submit(Callable<T> task) {
return threadPool.submit(task);
}
/**
* 关闭线程池（等待所有任务完成）
*/
@PreDestroy
public void shutdown() {
if (threadPool != null) {
threadPool.shutdown();
try {
if (!threadPool.awaitTermination(60, TimeUnit.SECONDS)) {
threadPool.shutdownNow();
}
} catch (InterruptedException e) {
threadPool.shutdownNow();
Thread.currentThread().interrupt();
}
}
}
/**
* 获取线程池状态
*
* @return 线程池状态信息
*/
public String getThreadPoolStatus() {
if (threadPool == null) {
return "Thread pool is not initialized.";
}
return String.format(
"Pool Status: [CorePoolSize: %d, ActiveThreads: %d, CompletedTasks: %d, QueueSize: %d]",
threadPool.getCorePoolSize(),
threadPool.getActiveCount(),
threadPool.getCompletedTaskCount(),
threadPool.getQueue().size()
);
}
}
2.5 使用线程池工具类
在业务代码中注入 ThreadPoolUtil，并提交任务：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class TaskService {
@Autowired
private ThreadPoolUtil threadPoolUtil;
public void runTask() {
// 提交 Runnable 任务
threadPoolUtil.execute(() -> {
System.out.println("Runnable task is running.");
});
// 提交 Callable 任务并获取结果
Future<String> future = threadPoolUtil.submit(() -> {
Thread.sleep(1000);
return "Callable task result";
});
try {
System.out.println("Callable task result: " + future.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
// 打印线程池状态
System.out.println(threadPoolUtil.getThreadPoolStatus());
}
}
2.6 测试线程池工具类
编写单元测试，验证线程池的功能：
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
public class ThreadPoolUtilTest {
@Autowired
private TaskService taskService;
@Test
public void testThreadPool() {
taskService.runTask();
}
}
3. 配置文件的灵活性
通过 application.yml 配置文件，可以灵活调整线程池的参数，而无需修改代码。例如：
调整核心线程数：
thread-pool: core-pool-size: 20调整任务队列容量：
thread-pool: queue-capacity: 200调整线程名称前缀：
thread-pool: thread-name-prefix: "app-thread-"
4. 总结
通过将线程池的配置参数提取到 application.yml 中，并结合 Spring Boot 的依赖注入机制，我们可以实现一个灵活、可配置的多线程工具类。这种方式不仅提高了代码的可维护性，还能根据实际需求动态调整线程池的行为，是 Spring Boot 项目中管理多线程任务的推荐做法。希望本文能帮助你更好地理解和应用 Spring Boot 中的多线程编程技术！