【线程与线程池】线程数设置(四)

0. 全局使用一个线程池

import java.util.concurrent.*;public class GlobalThreadPool {// 单例线程池private static final ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(10,                      // 核心线程数50,                      // 最大线程数60L, TimeUnit.SECONDS,   // 空闲线程最大存活时间new LinkedBlockingQueue<>(1000), // 工作队列new ThreadFactory() {private final ThreadFactory defaultFactory = Executors.defaultThreadFactory();private int counter = 0;@Overridepublic Thread newThread(Runnable r) {Thread thread = defaultFactory.newThread(r);thread.setName("global-thread-" + counter++);return thread;}},new ThreadPoolExecutor.AbortPolicy()  // 拒绝策略);private GlobalThreadPool() {// 私有构造防止实例化}public static ThreadPoolExecutor getExecutor() {return EXECUTOR;}
}

业务中使用

import java.util.concurrent.Future;public class Demo {public void runTask() {Runnable task = () -> {System.out.println("执行任务：" + Thread.currentThread().getName());};// 提交任务GlobalThreadPool.getExecutor().execute(task);}
}

也可以使用 submit() 获取 Future 对象：

Future<String> future = GlobalThreadPool.getExecutor().submit(() -> {// 业务逻辑return "result";
});

优雅关闭线程池（如在应用退出时）

public class ShutdownHook {public static void register() {Runtime.getRuntime().addShutdownHook(new Thread(() -> {System.out.println("关闭全局线程池...");GlobalThreadPool.getExecutor().shutdown();try {if (!GlobalThreadPool.getExecutor().awaitTermination(60, TimeUnit.SECONDS)) {GlobalThreadPool.getExecutor().shutdownNow();}} catch (InterruptedException e) {GlobalThreadPool.getExecutor().shutdownNow();}}));}
}在 Spring Boot 中可以在 @PostConstruct 中调用注册：@Component
public class AppInitializer {@PostConstructpublic void init() {ShutdownHook.register();}
}

另一种方法

在 Spring Boot 中，更建议使用 Spring 的 @Bean + 注入方式统一线程池，例如：import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import javax.annotation.PreDestroy;
import java.util.concurrent.*;@Configuration
public class ThreadPoolConfig {@Value("${threadpool.corePoolSize:10}")private int corePoolSize;@Value("${threadpool.maxPoolSize:50}")private int maxPoolSize;@Value("${threadpool.queueCapacity:1000}")private int queueCapacity;@Value("${threadpool.keepAliveSeconds:60}")private long keepAliveSeconds;@Value("${threadpool.threadNamePrefix:global-pool}")private String threadNamePrefix;@Value("${threadpool.rejectedPolicy:CallerRunsPolicy}")private String rejectedPolicy;private ThreadPoolExecutor executor;@Bean(name = "globalExecutor", destroyMethod = "") // 禁用 Spring 自动销毁，手动控制public Executor globalExecutor() {executor = new ThreadPoolExecutor(corePoolSize,maxPoolSize,keepAliveSeconds, TimeUnit.SECONDS,new LinkedBlockingQueue<>(queueCapacity),new CustomThreadFactory(threadNamePrefix),getRejectedExecutionHandler());return executor;}@PreDestroypublic void shutdown() {if (executor != null) {System.out.println("[ThreadPoolConfig] 正在关闭线程池...");executor.shutdown();try {if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {System.out.println("[ThreadPoolConfig] 超时未关闭，强制关闭线程池");executor.shutdownNow();}} catch (InterruptedException e) {executor.shutdownNow();Thread.currentThread().interrupt();System.out.println("[ThreadPoolConfig] 线程池关闭被中断，已强制关闭");}System.out.println("[ThreadPoolConfig] 线程池已成功关闭");}}private RejectedExecutionHandler getRejectedExecutionHandler() {switch (rejectedPolicy) {case "AbortPolicy":return new ThreadPoolExecutor.AbortPolicy();case "DiscardPolicy":return new ThreadPoolExecutor.DiscardPolicy();case "DiscardOldestPolicy":return new ThreadPoolExecutor.DiscardOldestPolicy();case "CallerRunsPolicy":default:return new ThreadPoolExecutor.CallerRunsPolicy();}}private static class CustomThreadFactory implements ThreadFactory {private final String prefix;private final ThreadGroup group;private int count = 1;CustomThreadFactory(String prefix) {this.prefix = prefix;this.group = Thread.currentThread().getThreadGroup();}@Overridepublic Thread newThread(Runnable r) {Thread t = new Thread(group, r, prefix + "-thread-" + count++);t.setDaemon(false);t.setPriority(Thread.NORM_PRIORITY);return t;}}
}

使用方式：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;import java.util.concurrent.Executor;@Service
public class TaskService {private final Executor globalExecutor;@Autowiredpublic TaskService(@Qualifier("globalExecutor") Executor globalExecutor) {this.globalExecutor = globalExecutor;}public void submitTasks() {for (int i = 1; i <= 5; i++) {int taskId = i;globalExecutor.execute(() -> {System.out.println(Thread.currentThread().getName() + " 正在执行任务: " + taskId);try {Thread.sleep(2000);  // 模拟任务执行耗时} catch (InterruptedException e) {Thread.currentThread().interrupt();}System.out.println(Thread.currentThread().getName() + " 完成任务: " + taskId);});}}
}@Qualifier("globalExecutor") 的作用是指定注入哪个具体的 Bean。是否必须加它，取决于你项目中是否存在多个同类型的 Bean。

启动入口调用（例如在 Spring Boot 主类或测试里）

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;@Component
public class Runner implements CommandLineRunner {private final TaskService taskService;public Runner(TaskService taskService) {this.taskService = taskService;}@Overridepublic void run(String... args) throws Exception {System.out.println("提交任务到全局线程池...");taskService.submitTasks();}
}

1. 按照任务类型对线程池进行分类

1.1 Netty的IO处理任务，就是典型的IO密集型任务

2. 混合型任务创建线程池时，如何确定线程数

P10