Java 线程池的预热（Warm-Up）
线程池预热 是指 在任务提交前，主动创建 核心线程，避免任务提交时触发 线程延迟创建，从而减少响应时间。
Java 默认情况下，线程池的核心线程是 懒加载（Lazy Load）的，只有在 任务提交后 才会创建线程。
🔹 为什么要进行线程池预热？
减少首次任务执行的延迟
线程池默认 不提前创建线程，首次提交任务时才会启动新线程，导致延迟。
避免突发流量造成的性能抖动
预热后，线程池 可立即接受任务，不受线程创建开销影响。
避免线程创建的性能损耗
线程创建是 昂贵的操作，尤其是在高并发环境下，提前创建线程可优化性能。
🔹 方法 1：使用 prestartCoreThread() 预热单个核心线程
Java 提供了 ThreadPoolExecutor.prestartCoreThread() 方法，可以 提前创建 1 个核心线程：
import java.util.concurrent.*;
public class ThreadPoolWarmUp {
public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(
5, // 核心线程数
10, // 最大线程数
60L, TimeUnit.SECONDS, // 空闲线程存活时间
new LinkedBlockingQueue<>()
);
// 预启动 1 个核心线程
executor.prestartCoreThread();
System.out.println("核心线程数: " + executor.getPoolSize()); // 输出 1
}
}✅ 优点：简单，立即创建 1 个 核心线程。
❌ 缺点：如果 核心线程数 > 1，需要多次调用。
🔹 方法 2：使用 prestartAllCoreThreads() 预热所有核心线程
import java.util.concurrent.*;
public class ThreadPoolWarmUp {
public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(
5, // 核心线程数
10, // 最大线程数
60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>()
);
// 预热所有核心线程
executor.prestartAllCoreThreads();
System.out.println("核心线程数: " + executor.getPoolSize()); // 输出 5
}
}✅ 优点：立即创建 所有 核心线程，适用于高并发需求。
✅ 推荐：如果你希望线程池 准备好立即处理任务，这是最好的方式。
🔹 方法 3：提交“空任务”让线程池创建线程
import java.util.concurrent.*;
public class ThreadPoolWarmUp {
public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(
5, 10, 60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>()
);
// 提交空任务来触发线程创建
for (int i = 0; i < 5; i++) {
executor.submit(() -> {
try {
Thread.sleep(10); // 让线程保持运行一段时间
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}
// 等待任务执行，确保线程创建
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("核心线程数: " + executor.getPoolSize()); // 输出 5
}
}✅ 优点：适用于 ScheduledThreadPool 等不支持 prestartAllCoreThreads() 的场景。
❌ 缺点：比直接 prestartAllCoreThreads() 方式稍慢，需要 sleep() 确保线程创建完成。
🔹 方法 4：使用 allowCoreThreadTimeOut(false) 保持核心线程存活
默认情况下，核心线程不会超时，但如果 allowCoreThreadTimeOut(true)，那么 即使核心线程创建了，如果长时间不处理任务，它们也会被销毁。
为了确保 预热后的核心线程不会被销毁，可以手动设置：
import java.util.concurrent.*;
public class ThreadPoolWarmUp {
public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(
5, 10, 60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>()
);
// 预热所有核心线程
executor.prestartAllCoreThreads();
// 确保核心线程不会被销毁
executor.allowCoreThreadTimeOut(false);
System.out.println("核心线程数: " + executor.getPoolSize()); // 输出 5
}
}✅ 优点：避免核心线程被销毁，确保预热效果持久。
✅ 推荐：如果核心线程数小（例如 5~10），可以用这个方式确保它们一直存活。
🔹 方法 5：创建 ScheduledThreadPoolExecutor 并初始化任务
对于 ScheduledThreadPoolExecutor（定时任务线程池），prestartAllCoreThreads() 无效，但可以通过 提前提交定时任务 来确保线程池预热：
import java.util.concurrent.*;
public class ScheduledThreadPoolWarmUp {
public static void main(String[] args) {
ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(5);
// 提前提交一个定时任务，确保线程池预热
executor.scheduleAtFixedRate(() -> {}, 0, 1, TimeUnit.SECONDS);
System.out.println("核心线程数: " + executor.getPoolSize()); // 可能会大于 0
}
}✅ 优点：适用于定时任务场景。
❌ 缺点：必须有实际任务触发线程创建。
🔹 总结
🔹 推荐做法
如果核心线程数较大（> 5） → 使用
prestartAllCoreThreads()预热所有核心线程。如果是
ScheduledThreadPoolExecutor→ 提交一个定时任务触发线程预热。如果核心线程可能空闲被销毁 →
allowCoreThreadTimeOut(false)确保它们存活。
这样可以确保线程池 在任务提交时不会有额外的线程创建延迟，从而提高性能！
