创建一个线程池时需要考虑哪些核心参数？请解释其含义。

八股文_Java并发基础题 0 3

参考回答

创建一个线程池时需要考虑以下核心参数：

核心线程数（corePoolSize）
- 指线程池中始终保持存活的线程数量。即使线程空闲，它们也不会被销毁。核心线程用于处理常规任务负载。
最大线程数（maximumPoolSize）
- 指线程池中允许的最大线程数量。当任务量大于核心线程的处理能力时，线程池会创建更多的线程，直到达到最大线程数。
任务队列（workQueue）
- 用于存放等待执行的任务。常见的队列类型有有界队列（ArrayBlockingQueue）、无界队列（LinkedBlockingQueue）等。任务队列可以影响线程池的行为。
线程存活时间（keepAliveTime）
- 指非核心线程在空闲状态下能存活的最长时间。当线程空闲时间超过该值时，会被销毁（如果当前线程数大于核心线程数）。
存活时间单位（timeUnit）
- 配合 keepAliveTime 使用，指定时间的单位（如秒、毫秒等）。
线程工厂（threadFactory）
- 用于创建线程，可以自定义线程的名称、优先级等，便于调试和监控。
拒绝策略（handler）
- 当线程池和任务队列都满时，决定如何处理新提交的任务。常见策略包括丢弃任务、抛出异常、调用者执行等。

这些参数决定了线程池的行为，必须根据实际场景合理配置。

详细讲解与拓展

1. 核心线程数（corePoolSize）

核心线程是线程池中不会被销毁的线程，除非线程池被关闭。
意义：确保一定数量的线程始终存在，可以立即处理任务，而不需要重新创建线程。

示例：
假设核心线程数为 2，当提交了 3 个任务时：

前两个任务由核心线程处理。
第三个任务会进入任务队列，等待处理。

注意：

核心线程数设置过小可能导致任务堆积。
可以通过 allowCoreThreadTimeOut(true) 让核心线程也在空闲时销毁。

2. 最大线程数（maximumPoolSize）

最大线程数是线程池中允许存在的线程数量上限。
意义：当任务量超出核心线程数且任务队列满时，线程池会创建新线程处理任务，直到达到最大线程数。

示例：
假设核心线程数为 2，最大线程数为 4，队列长度为 1：

提交 3 个任务：两个核心线程执行任务，第 3 个任务进入队列。
提交第 4 个任务：队列已满，线程池创建一个非核心线程处理任务。

注意：

设置过大可能导致系统资源耗尽。
在高并发场景下，最大线程数需要根据硬件和任务特性合理设置。

3. 任务队列（workQueue）

任务队列用于存放等待执行的任务。
不同的队列类型会影响线程池的行为：

有界队列（如 ArrayBlockingQueue）：
- 有固定容量，当队列满时，线程池会创建非核心线程处理任务，直到达到最大线程数。
无界队列（如 LinkedBlockingQueue）：
- 队列长度理论上无限大，任务会被无限堆积，除非内存耗尽。线程池通常只使用核心线程，非核心线程几乎不会被创建。
优先级队列（如 PriorityBlockingQueue）：
- 任务按优先级排序，但需任务实现 Comparable 接口。

示例：

BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(5);

4. 线程存活时间（keepAliveTime）

当线程数超过核心线程数时，非核心线程在空闲超过 keepAliveTime 后会被销毁。
意义：减少空闲线程占用的资源。

注意：

默认情况下，keepAliveTime 只作用于非核心线程，但可以通过 allowCoreThreadTimeOut(true) 让核心线程也遵循该规则。

5. 存活时间单位（timeUnit）

配合 keepAliveTime 使用，指定时间的单位。
常见单位有：
- TimeUnit.SECONDS
- TimeUnit.MILLISECONDS

示例：

long keepAliveTime = 60L;
TimeUnit unit = TimeUnit.SECONDS;

6. 线程工厂（threadFactory）

线程工厂负责创建线程，可以自定义线程的名称、优先级等。
意义：便于监控和调试。

示例：

ThreadFactory factory = r -> {
    Thread t = new Thread(r);
    t.setName("CustomThread-" + t.getId());
    return t;
};
ExecutorService executor = Executors.newFixedThreadPool(2, factory);

7. 拒绝策略（handler）

当线程池和任务队列都满时，线程池会调用拒绝策略处理新任务。
ThreadPoolExecutor 提供了 4 种内置策略：

AbortPolicy（默认）：抛出 RejectedExecutionException 异常。
CallerRunsPolicy：由调用线程（提交任务的线程）执行任务。
DiscardPolicy：直接丢弃任务，不抛异常。
DiscardOldestPolicy：丢弃队列中最旧的任务，尝试重新提交新任务。

示例：

RejectedExecutionHandler handler = new ThreadPoolExecutor.CallerRunsPolicy();
ExecutorService executor = new ThreadPoolExecutor(
    2, 4, 60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(2),
    handler
);

实例分析：自定义线程池

创建一个自定义线程池，合理配置参数：

import java.util.concurrent.*;

public class CustomThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(
            2,                // 核心线程数
            4,                // 最大线程数
            60L,              // 空闲线程存活时间
            TimeUnit.SECONDS, // 存活时间单位
            new ArrayBlockingQueue<>(2),          // 有界任务队列
            Executors.defaultThreadFactory(),     // 默认线程工厂
            new ThreadPoolExecutor.AbortPolicy()  // 拒绝策略
        );

        for (int i = 0; i < 10; i++) {
            final int task = i;
            threadPool.execute(() -> {
                System.out.println("执行任务: " + task + " by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        threadPool.shutdown();
    }
}

总结

创建线程池时需要考虑以下核心参数：

核心线程数：决定基本处理能力。
最大线程数：限制最大并发任务数。
任务队列：存放未处理任务，决定线程池行为。
线程存活时间：控制空闲线程的存活。
存活时间单位：与存活时间配合使用。
线程工厂：自定义线程，便于监控。
拒绝策略：控制任务无法处理时的行为。