线程池详解

1. 线程池的定义

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。

主要作用：

降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗
提高响应速度：当任务到达时，任务可以不需要等待线程创建就能立即执行
提高线程的可管理性：线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性

2. 线程池的参数有哪些

线程池的核心参数（以ThreadPoolExecutor为例）：

核心参数

corePoolSize：核心线程数
maximumPoolSize：最大线程数
keepAliveTime：线程空闲时间
unit：空闲时间单位
workQueue：工作队列
threadFactory：线程工厂
handler：拒绝策略处理器

3. 几种线程池的区别

Java通过Executors提供了几种常用的线程池：

3.1 FixedThreadPool（固定大小线程池）

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);

特点：固定大小的线程池，核心线程数=最大线程数
队列：LinkedBlockingQueue（无界队列）
适用场景：适用于负载较重的服务器

3.2 CachedThreadPool（缓存线程池）

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

特点：核心线程数为0，最大线程数为Integer.MAX_VALUE
队列：SynchronousQueue（同步队列）
适用场景：执行很多短期异步任务

3.3 SingleThreadExecutor（单线程线程池）

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

特点：只有一个工作线程，保证所有任务按顺序执行
队列：LinkedBlockingQueue（无界队列）
适用场景：需要顺序执行任务的场景

3.4 ScheduledThreadPool（定时线程池）

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

特点：支持定时及周期性任务执行
适用场景：需要执行定时任务的场景

4. 线程池的最大线程数是根据什么定义的

最大线程数的设置需要考虑以下因素：

4.1 系统资源

CPU密集型任务：最大线程数 ≈ CPU核心数 + 1
I/O密集型任务：最大线程数 ≈ CPU核心数 × (1 + 平均等待时间/平均工作时间)

4.2 业务需求

任务类型和数量
响应时间要求
系统吞吐量目标

4.3 经验公式

// CPU密集型
int cpuCount = Runtime.getRuntime().availableProcessors();
int maxThreads = cpuCount + 1;

// I/O密集型
int maxThreads = cpuCount * 2;
// 或者更精确的公式
int maxThreads = (int) (cpuCount / (1 - 阻塞系数));

5. 线程池的阻塞队列

5.1 常用阻塞队列类型

队列类型	特点	适用场景
LinkedBlockingQueue	无界队列（默认Integer.MAX_VALUE）	任务量不可预知，但系统资源充足
ArrayBlockingQueue	有界队列，需要指定容量	防止资源耗尽，控制任务积压
SynchronousQueue	同步队列，不存储元素	直接传递任务，适用于短任务
PriorityBlockingQueue	优先级队列	需要按优先级处理任务

5.2 队列选择策略

快速任务：SynchronousQueue
无限任务：LinkedBlockingQueue
有限任务：ArrayBlockingQueue
优先级任务：PriorityBlockingQueue

6. 线程池的拒绝策略

当线程池和工作队列都满了，新提交的任务会触发拒绝策略：

6.1 内置拒绝策略

AbortPolicy（默认）

new ThreadPoolExecutor.AbortPolicy()

行为：直接抛出RejectedExecutionException异常
适用场景：需要明确知道任务被拒绝的场景

CallerRunsPolicy

new ThreadPoolExecutor.CallerRunsPolicy()

行为：由调用者线程执行该任务
适用场景：不允许任务丢失的场景

DiscardPolicy

new ThreadPoolExecutor.DiscardPolicy()

行为：直接丢弃任务，不抛出异常
适用场景：无关紧要的任务

DiscardOldestPolicy

new ThreadPoolExecutor.DiscardOldestPolicy()

行为：丢弃队列中最旧的任务，然后重新尝试执行
适用场景：新任务比旧任务更重要的场景

6.2 自定义拒绝策略

RejectedExecutionHandler customHandler = (r, executor) -> {
    // 自定义处理逻辑
    logger.warn("Task rejected, saving to database for retry later");
    saveTaskToDatabase(r);
};

7. 线程池最大的线程数和最大空闲时间配置

7.1 配置原则

最大线程数配置

// 根据任务类型配置
int corePoolSize;
int maximumPoolSize;

if (isCpuIntensive(taskType)) {
    // CPU密集型
    int cpuCores = Runtime.getRuntime().availableProcessors();
    corePoolSize = cpuCores;
    maximumPoolSize = cpuCores + 1;
} else if (isIoIntensive(taskType)) {
    // I/O密集型
    int cpuCores = Runtime.getRuntime().availableProcessors();
    corePoolSize = cpuCores;
    maximumPoolSize = cpuCores * 2;
} else {
    // 混合型
    int cpuCores = Runtime.getRuntime().availableProcessors();
    corePoolSize = cpuCores;
    maximumPoolSize = cpuCores * 3 / 2;
}

最大空闲时间配置

long keepAliveTime;
TimeUnit unit;

if (isHighFrequencyTask()) {
    // 高频任务，保持线程活跃
    keepAliveTime = 30L;
    unit = TimeUnit.SECONDS;
} else if (isLowFrequencyTask()) {
    // 低频任务，快速回收线程
    keepAliveTime = 5L;
    unit = TimeUnit.SECONDS;
} else {
    // 默认配置
    keepAliveTime = 60L;
    unit = TimeUnit.SECONDS;
}

7.2 完整配置示例

public ThreadPoolExecutor createThreadPool() {
    int cpuCores = Runtime.getRuntime().availableProcessors();
    
    return new ThreadPoolExecutor(
        // 核心线程数
        cpuCores,
        // 最大线程数
        cpuCores * 2,
        // 空闲线程存活时间
        60L,
        // 时间单位
        TimeUnit.SECONDS,
        // 工作队列
        new ArrayBlockingQueue<>(1000),
        // 线程工厂
        Executors.defaultThreadFactory(),
        // 拒绝策略
        new ThreadPoolExecutor.CallerRunsPolicy()
    );
}

7.3 监控和调优

// 监控线程池状态
ThreadPoolExecutor executor = createThreadPool();

// 定期监控
ScheduledExecutorService monitor = Executors.newScheduledThreadPool(1);
monitor.scheduleAtFixedRate(() -> {
    System.out.println("活跃线程数: " + executor.getActiveCount());
    System.out.println("核心线程数: " + executor.getCorePoolSize());
    System.out.println("最大线程数: " + executor.getMaximumPoolSize());
    System.out.println("队列大小: " + executor.getQueue().size());
    System.out.println("完成任务数: " + executor.getCompletedTaskCount());
}, 0, 30, TimeUnit.SECONDS);

通过合理的参数配置和持续的监控调优，可以构建出高性能、稳定的线程池，满足不同业务场景的需求。

CachedThreadPool（缓存线程池）为什么使用队列：SynchronousQueue（同步队列）

CachedThreadPool 使用 SynchronousQueue 的深度解析

1. SynchronousQueue 的特性

1.1 基本特点

零容量队列：不存储任何元素，每个插入操作必须等待对应的移除操作
直接传递：生产者线程和消费者线程直接交接任务，没有中间缓冲
同步机制：put() 和 take() 操作必须成对出现，否则会阻塞

1.2 工作模式

// SynchronousQueue 的工作方式
// 生产者 put() → 阻塞等待消费者 → 消费者 take() → 任务直接传递
// 如果没有消费者，生产者会一直阻塞

2. CachedThreadPool 的设计理念

2.1 核心设计目标

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

线程弹性伸缩：根据需要自动创建和销毁线程
即时响应：新任务到来时立即分配线程执行
无界线程数量：理论上可以创建无限多个线程（Integer.MAX_VALUE）

2.2 关键参数配置

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(
        0,                                  // 核心线程数 = 0
        Integer.MAX_VALUE,                  // 最大线程数 = 无限
        60L, TimeUnit.SECONDS,             // 空闲线程60秒后销毁
        new SynchronousQueue<Runnable>()    // 使用同步队列
    );
}

3. 为什么选择 SynchronousQueue

3.1 实现即时线程创建

工作流程：

新任务提交到线程池
由于核心线程数为0，先尝试提交到 SynchronousQueue
SynchronousQueue 没有容量，立即尝试创建新线程
新线程直接从 SynchronousQueue 中获取任务执行

// 伪代码展示工作流程
public void execute(Runnable task) {
    if (当前线程数 < 最大线程数) {
        // 创建新线程执行任务
        createNewThread(task);
    } else {
        // 对于CachedThreadPool，由于SynchronousQueue的特性
        // 这个分支很少执行，通常会直接创建新线程
    }
}

3.2 避免任务排队

// 对比不同队列的行为：

// 1. LinkedBlockingQueue（FixedThreadPool使用）
// 任务提交 → 队列排队 → 线程从队列获取执行
// 问题：任务可能长时间排队，响应延迟

// 2. SynchronousQueue（CachedThreadPool使用）
// 任务提交 → 立即创建线程执行 → 无排队
// 优势：零延迟，立即执行

4. 具体工作场景分析

4.1 任务提交时的处理逻辑

// 详细的任务处理流程
public void execute(Runnable command) {
    // 1. 首先检查是否有空闲线程
    // 2. 由于核心线程数为0，通常没有空闲线程
    // 3. 尝试将任务放入SynchronousQueue
    // 4. SynchronousQueue无法立即接受（需要配对消费者）
    // 5. 触发创建新线程的逻辑
    // 6. 新线程从SynchronousQueue中take()任务
    // 7. 任务被立即执行
}

4.2 线程生命周期管理

// 线程创建和销毁的时机
public void run() {
    Runnable task = initialTask;
    while (task != null || (task = getTask()) != null) {
        task.run();
        task = null;
    }
    // 线程退出，被销毁
}

private Runnable getTask() {
    // 从SynchronousQueue中获取任务
    // 如果60秒内没有获取到任务，返回null，线程终止
    return workQueue.poll(keepAliveTime, TimeUnit.SECONDS);
}

5. 与其他队列的对比

5.1 性能对比分析

队列类型	任务排队	线程创建	内存使用	适用场景
SynchronousQueue	无排队	立即创建	线程开销大	短任务、高并发
LinkedBlockingQueue	可能长排队	固定数量	队列内存开销	长任务、稳定负载
ArrayBlockingQueue	有限排队	固定数量	固定内存开销	可控资源

5.2 实际效果演示

public class CachedThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        
        // 提交100个短任务
        for (int i = 0; i < 100; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("Task " + taskId + " executed by " + 
                                 Thread.currentThread().getName());
                try {
                    Thread.sleep(100); // 模拟短任务
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        executor.shutdown();
    }
}

输出结果可能显示：

Task 0 executed by pool-1-thread-1
Task 1 executed by pool-1-thread-2
Task 2 executed by pool-1-thread-3
...
Task 99 executed by pool-1-thread-25

可以看到创建了多个线程来并行执行任务。

6. 优势和风险

6.1 优势

零延迟执行：任务无需排队，立即执行
自动伸缩：根据负载自动调整线程数量
资源高效：空闲线程自动回收，避免资源浪费
适合短任务：特别适合执行时间短的异步任务

6.2 风险和限制

// 风险示例：无限制创建线程
ExecutorService executor = Executors.newCachedThreadPool();

// 提交大量长任务可能导致OOM
for (int i = 0; i < 100000; i++) {
    executor.execute(() -> {
        try {
            Thread.sleep(10000); // 长任务
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    });
}

风险点：

可能创建过多线程导致OOM
不适合执行时间长的任务
线程创建销毁开销大

7. 最佳实践

7.1 适用场景

HTTP请求处理
短时间的数据处理
高并发的短期任务
测试环境使用

7.2 不适用场景

长时间运行的任务
对资源使用有严格限制的生产环境
需要控制并发数量的场景

7.3 替代方案

// 如果需要控制最大线程数，使用自定义ThreadPoolExecutor
ExecutorService customExecutor = new ThreadPoolExecutor(
    0, 100,  // 控制最大线程数
    60L, TimeUnit.SECONDS,
    new SynchronousQueue<Runnable>(),
    new ThreadPoolExecutor.CallerRunsPolicy()  // 添加拒绝策略
);

总结

CachedThreadPool 使用 SynchronousQueue 的核心原因是实现任务的即时执行和线程的弹性伸缩。这种设计使得：

零缓冲：任务不排队，立即寻找可用线程或创建新线程
自动扩容：根据任务压力自动增加线程数量
自动收缩：空闲线程自动回收，避免资源浪费

这种设计完美契合了 CachedThreadPool “处理大量短期异步任务” 的设计目标，但需要注意在生产环境中谨慎使用，避免无限制创建线程导致系统资源耗尽。

分享

线程池相关八股文