Java线程池知识点-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_52803316/article/details/149154833

一、线程池的核心概念与作用

线程池是Java并发编程中用于管理线程生命周期的机制，通过预先创建一定数量的线程并复用它们执行任务，避免了频繁创建和销毁线程带来的性能开销（如线程创建时的内存分配、上下文切换成本）。其核心作用包括：降低资源消耗（复用线程）、提高响应速度（任务无需等待线程创建）、控制并发量（防止线程过多导致系统资源耗尽）、统一管理任务（便于监控和调优）。

二、Java线程池核心类与接口

Java线程池基于java.util.concurrent包下的Executor框架实现，核心接口和类如下：

1. 核心接口

Executor：最顶层接口，定义了任务执行的基本方法void execute(Runnable command)，仅支持提交Runnable任务。
ExecutorService：继承Executor，扩展了线程池的生命周期管理（如shutdown()、shutdownNow()）、任务提交（支持Callable任务并返回Future）等能力，是线程池操作的核心接口。

2. 核心实现类

ThreadPoolExecutor：线程池的核心实现类，几乎所有线程池功能均基于此类实现，支持自定义核心参数（如线程数、队列、拒绝策略等）。
ScheduledThreadPoolExecutor：继承ThreadPoolExecutor，支持定时/周期性任务调度，实现了ScheduledExecutorService接口。

3. 工具类

Executors：提供了创建线程池的工厂方法（如newFixedThreadPool()、newCachedThreadPool()），但阿里巴巴Java开发手册明确不推荐使用，因其默认参数可能导致资源耗尽风险（如无界队列导致OOM）。

三、ThreadPoolExecutor核心参数解析

ThreadPoolExecutor的构造方法是理解线程池的关键，其核心参数如下（以ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)为例）：

参数名	含义与作用
corePoolSize	核心线程数：线程池长期维持的线程数量，即使线程空闲也不会销毁（除非设置`allowCoreThreadTimeOut=true`）。
maximumPoolSize	最大线程数：线程池允许创建的最大线程数，当核心线程和队列均满时，可临时扩容至此值。
keepAliveTime	空闲线程存活时间：非核心线程（当`corePoolSize < maximumPoolSize`时）空闲后的存活时间，超时后销毁。
unit	`keepAliveTime`的时间单位（如`TimeUnit.SECONDS`）。
workQueue	工作队列：用于存储等待执行的任务，当核心线程满时，新任务会进入队列等待。
threadFactory	线程工厂：用于创建线程，可自定义线程名称、优先级、是否为守护线程等（默认使用`Executors.defaultThreadFactory()`）。
handler	拒绝策略：当线程池和队列均满时，对新提交任务的处理策略（默认使用`AbortPolicy`）。

代码示例：手动创建线程池（推荐方式）

// 手动创建线程池（生产环境推荐）
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, // corePoolSize：核心线程数
    10, // maximumPoolSize：最大线程数
    60, // keepAliveTime：空闲线程存活时间（秒）
    TimeUnit.SECONDS, // 时间单位
    new ArrayBlockingQueue<>(100), // 有界队列（容量100），避免OOM
    new ThreadFactory() { // 自定义线程工厂（设置线程名称）
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "order-pool-thread-" + threadNumber.getAndIncrement());
            t.setDaemon(false); // 非守护线程（避免主线程退出时强制中断任务）
            t.setPriority(Thread.NORM_PRIORITY); // 正常优先级
            return t;
        }
    },
    new ThreadPoolExecutor.AbortPolicy() // 拒绝策略：抛出异常（关键任务推荐）
);

// 允许核心线程超时销毁（可选，默认false）
executor.allowCoreThreadTimeOut(true);

四、线程池工作原理（任务执行流程）

当通过execute(Runnable)或submit(Callable)提交任务时，线程池按以下流程处理：

判断核心线程是否空闲：若核心线程数未达corePoolSize，则创建新核心线程执行任务；
核心线程满，判断队列是否未满：若核心线程均在工作，且workQueue未满，则将任务加入队列等待；
队列满，判断是否可扩容至最大线程数：若队列已满，且当前线程数未达maximumPoolSize，则创建非核心线程执行任务；
最大线程数已满，执行拒绝策略：若线程数已达maximumPoolSize且队列满，则触发handler指定的拒绝策略。

注意：若设置allowCoreThreadTimeOut(true)，核心线程在空闲keepAliveTime后也会被销毁，此时corePoolSize的“长期维持”特性失效。

代码示例：提交任务到线程池

// 1. 提交Runnable任务（无返回值）
executor.execute(() -> {
    System.out.println("执行Runnable任务，线程名：" + Thread.currentThread().getName());
    try {
        Thread.sleep(1000); // 模拟任务执行
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
});

// 2. 提交Callable任务（有返回值）
Future<String> future = executor.submit(() -> {
    System.out.println("执行Callable任务，线程名：" + Thread.currentThread().getName());
    Thread.sleep(1000);
    return "任务执行结果";
});

// 获取Callable任务结果（阻塞等待）
try {
    String result = future.get(2, TimeUnit.SECONDS); // 设置超时时间
    System.out.println("Callable任务结果：" + result);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt(); // 恢复中断状态
} catch (ExecutionException | TimeoutException e) {
    future.cancel(true); // 超时或异常时取消任务
}

五、工作队列（BlockingQueue）类型与特性

workQueue必须是阻塞队列（BlockingQueue），Java提供了多种实现，特性如下：

队列类型	特点与适用场景
ArrayBlockingQueue	基于数组的有界队列，需指定容量（如`new ArrayBlockingQueue<>(100)`），避免OOM，适用于任务量可控场景。
LinkedBlockingQueue	基于链表的队列，默认容量为`Integer.MAX_VALUE`（无界），若未指定容量可能因任务堆积导致OOM；指定容量后为有界队列，适用于任务量波动较大但需控制队列长度的场景。
SynchronousQueue	不存储任务的队列（容量为0），提交任务时必须立即有线程接收，否则触发扩容（需配合`maximumPoolSize`使用），适用于任务需快速处理、不允许排队的场景（如`newCachedThreadPool`）。
PriorityBlockingQueue	支持按优先级排序的无界队列（默认自然排序，可自定义`Comparator`），适用于任务需按优先级执行的场景，但需注意无界特性可能导致OOM。

代码示例：队列使用场景对比

// 1. 有界队列（推荐）：任务量可控时使用
BlockingQueue<Runnable> arrayQueue = new ArrayBlockingQueue<>(100); // 容量100

// 2. 无界队列（谨慎使用）：任务量不可控时可能OOM
BlockingQueue<Runnable> linkedQueue = new LinkedBlockingQueue<>(); // 默认容量Integer.MAX_VALUE

// 3. 同步队列：任务需即时处理，无缓冲
BlockingQueue<Runnable> syncQueue = new SynchronousQueue<>();

// 4. 优先级队列：按任务优先级执行
BlockingQueue<Runnable> priorityQueue = new PriorityBlockingQueue<>(100, 
    Comparator.comparingInt(task -> ((PriorityTask) task).getPriority()));

六、拒绝策略（RejectedExecutionHandler）类型

当线程池无法接收新任务（线程数达maximumPoolSize且队列满）时，触发拒绝策略。JDK提供4种默认策略，也可通过实现RejectedExecutionHandler接口自定义：

策略类型	行为描述	适用场景
AbortPolicy	抛出`RejectedExecutionException`异常，阻止系统继续运行。	关键任务（如交易处理），需明确感知任务提交失败，避免静默丢失。
CallerRunsPolicy	由提交任务的线程（调用者线程）直接执行任务，减缓新任务提交速度（“回压”效果）。	并发量不高、需避免任务丢失的场景（如日志收集），通过调用者线程执行任务降低系统负载。
DiscardPolicy	直接丢弃新任务，无任何提示。	非核心任务（如统计上报），允许偶尔丢失，且无需感知失败。
DiscardOldestPolicy	丢弃队列中最旧的任务（队首任务），然后尝试提交新任务。	任务有“时效性”，旧任务过期后可丢弃（如实时数据处理），但可能导致队列中重要旧任务丢失。

代码示例：自定义拒绝策略

// 自定义拒绝策略：记录日志+重试机制
RejectedExecutionHandler customHandler = new RejectedExecutionHandler() {
    private final Logger log = LoggerFactory.getLogger(MyRejectedHandler.class);
    private final ScheduledExecutorService retryExecutor = Executors.newSingleThreadScheduledExecutor();

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        if (!executor.isShutdown()) {
            log.warn("任务被拒绝，尝试重试，当前队列大小：{}", executor.getQueue().size());
            // 5秒后重试提交任务
            retryExecutor.schedule(() -> executor.submit(r), 5, TimeUnit.SECONDS);
        }
    }
};

// 使用自定义拒绝策略创建线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, 10, 60, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(100),
    Executors.defaultThreadFactory(),
    customHandler // 应用自定义策略
);

七、Executors创建的线程池类型（不推荐使用）

Executors提供了便捷的线程池创建方法，但存在资源风险，需了解其实现细节：

方法名	核心参数配置	风险点
`newFixedThreadPool(n)`	`corePoolSize = maximumPoolSize = n`，队列`LinkedBlockingQueue`（无界）。	任务堆积时队列无限增长，导致OOM。
`newSingleThreadExecutor()`	`corePoolSize = maximumPoolSize = 1`，队列`LinkedBlockingQueue`（无界）。	同`newFixedThreadPool(1)`，队列无界导致OOM；且线程唯一，任务串行执行效率低。
`newCachedThreadPool()`	`corePoolSize = 0`，`maximumPoolSize = Integer.MAX_VALUE`，队列`SynchronousQueue`。	任务量突增时创建大量线程（可达`Integer.MAX_VALUE`），导致CPU/内存耗尽。
`newScheduledThreadPool(n)`	核心线程数`n`，最大线程数`Integer.MAX_VALUE`，队列`DelayedWorkQueue`（无界）。	定时任务过多时队列堆积，导致OOM；最大线程数过大可能创建过多线程。

代码示例：Executors创建线程池（不推荐）

// 1. FixedThreadPool：固定线程数，无界队列（风险：OOM）
ExecutorService fixedExecutor = Executors.newFixedThreadPool(5);

// 2. SingleThreadExecutor：单线程，无界队列（风险：OOM+串行执行效率低）
ExecutorService singleExecutor = Executors.newSingleThreadExecutor();

// 3. CachedThreadPool：缓存线程池（风险：创建大量线程导致资源耗尽）
ExecutorService cachedExecutor = Executors.newCachedThreadPool();

// 4. ScheduledThreadPool：定时任务线程池（风险：无界队列+最大线程数过大）
ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(3);
// 定时任务示例：延迟1秒执行，每3秒重复一次
scheduledExecutor.scheduleAtFixedRate(() -> System.out.println("定时任务执行"), 1, 3, TimeUnit.SECONDS);

八、线程池状态与生命周期

ThreadPoolExecutor通过原子变量ctl（高3位表示状态，低29位表示线程数）管理状态，共5种状态：

状态名	描述	触发方式	后续行为
RUNNING	正常运行状态，可接收新任务并处理队列任务。	线程池初始化时默认状态。	持续处理任务，直至调用`shutdown()`或`shutdownNow()`。
SHUTDOWN	关闭状态，不接收新任务，但继续处理队列中已有的任务。	调用`shutdown()`。	队列任务处理完毕后，进入`TIDYING`状态。
STOP	停止状态，不接收新任务，中断正在执行的任务，清空队列。	调用`shutdownNow()`。	所有任务终止、活动线程数为0后，进入`TIDYING`状态。
TIDYING	整理状态，所有任务已终止，活动线程数为0，准备执行`terminated()`钩子方法。	`SHUTDOWN`状态下队列空且线程数为0；或`STOP`状态下线程数为0。	执行`terminated()`后，进入`TERMINATED`状态。
TERMINATED	终止状态，`terminated()`方法执行完毕。	`TIDYING`状态结束后自动进入。	线程池生命周期结束，不可再提交任务。

状态转换路径：RUNNING → SHUTDOWN → TIDYING → TERMINATED 或 RUNNING → STOP → TIDYING → TERMINATED。

代码示例：线程池生命周期管理

// 1. 启动线程池（初始化后默认RUNNING状态）
ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100));

// 2. 提交任务（RUNNING状态下可接收）
executor.execute(() -> System.out.println("任务执行中"));

// 3. 平缓关闭：不接收新任务，处理完队列中任务
executor.shutdown();
try {
    // 等待10秒，若线程池未终止则强制关闭
    if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
        executor.shutdownNow(); // 强制关闭，中断正在执行的任务
    }
} catch (InterruptedException e) {
    executor.shutdownNow(); // 捕获中断异常，强制关闭
    Thread.currentThread().interrupt();
}

// 4. 检查状态
System.out.println("线程池是否终止：" + executor.isTerminated());

九、线程池监控与调优

1. 监控指标

通过ThreadPoolExecutor的方法可获取线程池运行状态，关键指标包括：

getActiveCount()：当前活动线程数（正在执行任务的线程）；
getCorePoolSize()/getMaximumPoolSize()：核心/最大线程数；
getQueue().size()：队列中等待的任务数；
getCompletedTaskCount()：已完成的任务总数；
getTaskCount()：总任务数（已完成+正在执行+队列中）。

2. 参数调优原则

核心线程数（corePoolSize）：
- CPU密集型任务（如计算）：设为CPU核心数 + 1（减少线程切换开销）；
- IO密集型任务（如网络请求、文件读写）：设为CPU核心数 * 2或更高（线程等待IO时可让出CPU）。
  注：CPU核心数可通过Runtime.getRuntime().availableProcessors()获取。
最大线程数（maximumPoolSize）：
需结合队列容量综合设置，避免过大导致线程切换频繁。通常不超过CPU核心数 * 10（经验值）。
队列（workQueue）：
必须使用有界队列（如ArrayBlockingQueue指定容量），避免无界队列导致OOM；容量需根据任务提交速率和处理速率平衡（如每秒提交100任务，每个任务处理1秒，队列容量可设为200~300，预留缓冲）。
拒绝策略（handler）：
核心任务用AbortPolicy（抛异常报警），非核心任务用DiscardPolicy或自定义策略（如记录日志+重试）。

代码示例：线程池监控与动态调优

// 1. 监控线程池状态（可定期执行）
ScheduledExecutorService monitor = Executors.newSingleThreadScheduledExecutor();
monitor.scheduleAtFixedRate(() -> {
    System.out.println("=== 线程池监控信息 ===");
    System.out.println("活动线程数：" + executor.getActiveCount());
    System.out.println("队列等待数：" + executor.getQueue().size());
    System.out.println("已完成任务数：" + executor.getCompletedTaskCount());
    System.out.println("核心线程数：" + executor.getCorePoolSize());
    System.out.println("最大线程数：" + executor.getMaximumPoolSize());
}, 0, 5, TimeUnit.SECONDS); // 每5秒监控一次

// 2. 动态调整核心线程数（根据业务负载）
if (executor.getQueue().size() > 50) { // 队列积压超过50时扩容
    executor.setCorePoolSize(8); // 核心线程数从5调整为8
}

// 3. 动态调整最大线程数
executor.setMaximumPoolSize(15); // 最大线程数从10调整为15

十、最佳实践与常见问题

1. 最佳实践

手动创建线程池：使用ThreadPoolExecutor构造方法，显式指定核心参数（尤其是有界队列和合理的拒绝策略），避免Executors的隐式风险。
自定义线程工厂：通过ThreadFactory设置线程名称（如"order-pool-thread-%d"），便于日志排查和监控。
优雅关闭线程池：程序退出前调用shutdown()（平缓关闭）或shutdownNow()（强制关闭），并通过awaitTermination()等待任务处理完毕，避免任务丢失。
监控线程池状态：结合业务需求，定期采集线程池指标（如活动线程数、队列长度），设置告警阈值（如队列长度超过容量80%时告警）。

2. 常见问题

线程池未关闭导致资源泄漏：长期运行的服务中，若线程池不再使用却未关闭，核心线程会一直占用资源，需在生命周期结束时显式关闭。
核心线程数设置过小：导致任务大量堆积在队列，响应延迟增加；设置过大则线程切换频繁，CPU利用率下降。
无界队列风险：LinkedBlockingQueue未指定容量时，任务持续提交会导致队列无限增长，最终触发OOM。
拒绝策略选择不当：如核心任务使用DiscardPolicy导致任务静默丢失，未及时发现问题。

代码示例：生产环境线程池配置模板

/**
 * 生产环境线程池配置示例（IO密集型任务）
 */
public class OrderThreadPool {
    private static final int CPU_CORES = Runtime.getRuntime().availableProcessors();
    private static final ThreadPoolExecutor EXECUTOR;

    static {
        // 核心参数配置
        int corePoolSize = CPU_CORES * 2; // IO密集型：CPU核心数 * 2
        int maximumPoolSize = CPU_CORES * 4; // 最大线程数不超过CPU核心数 * 4
        long keepAliveTime = 60;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(200); // 有界队列，容量200
        ThreadFactory threadFactory = new ThreadFactory() {
            private final AtomicInteger threadNum = new AtomicInteger(1);
            @Override
            public Thread newThread(Runnable r) {
                Thread t = new Thread(r, "order-service-pool-" + threadNum.getAndIncrement());
                t.setDaemon(false);
                t.setPriority(Thread.NORM_PRIORITY);
                return t;
            }
        };
        // 自定义拒绝策略：记录日志+告警
        RejectedExecutionHandler handler = (r, executor) -> {
            // 记录被拒绝任务信息
            log.error("订单任务被拒绝，当前队列大小：{}，任务：{}", executor.getQueue().size(), r.toString());
            // 发送告警通知（如邮件、短信）
            alertService.send("线程池任务拒绝告警", "队列已满，任务被拒绝");
        };

        EXECUTOR = new ThreadPoolExecutor(
            corePoolSize, maximumPoolSize, keepAliveTime, unit,
            workQueue, threadFactory, handler
        );
        // 允许核心线程超时销毁（低负载时释放资源）
        EXECUTOR.allowCoreThreadTimeOut(true);
    }

    public static ThreadPoolExecutor getExecutor() {
        return EXECUTOR;
    }

    // 优雅关闭线程池（在应用关闭时调用）
    public static void shutdown() {
        EXECUTOR.shutdown();
        try {
            if (!EXECUTOR.awaitTermination(30, TimeUnit.SECONDS)) {
                EXECUTOR.shutdownNow();
            }
        } catch (InterruptedException e) {
            EXECUTOR.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

总结

Java线程池是并发编程的核心组件，通过合理配置ThreadPoolExecutor的核心参数（线程数、队列、拒绝策略等），可有效提升系统性能和稳定性。实际应用中需结合任务类型（CPU/IO密集）、系统资源（CPU核心数、内存）和业务需求（任务重要性、时效性）进行参数调优，并通过监控及时发现潜在问题，避免资源耗尽或任务丢失风险。