Java 多线程与线程池完整笔记

一、线程池基础

1.1 什么是线程池

线程池是一种多线程处理模式，它在系统启动时预先创建一定数量的线程放入池中。这些线程在没有任务时处于等待状态，当有任务提交时，池中某个空闲线程会被唤醒执行任务。任务执行完成后，线程并不会被销毁，而是返回池中继续等待下一个任务。

┌─────────────────────────────────────────────────┐
│                  线程池架构                       │
├─────────────────────────────────────────────────┤
│  ┌─────┐  ┌─────┐  ┌─────┐  ┌─────┐            │
│  │线程1│  │线程2│  │线程3│  │线程N│   ← 常驻线程 │
│  └──┬──┘  └──┬──┘  └──┬──┘  └──┬──┘            │
│     │         │         │         │              │
│     └─────────┴────┬────┴─────────┘              │
│                    ▼                             │
│            ┌───────────────┐                     │
│            │   任务队列     │  ← 缓冲待处理任务    │
│            └───────────────┘                     │
└─────────────────────────────────────────────────┘

1.2 为什么需要线程池

二、ThreadPoolExecutor 核心参数详解

2.1 七个核心参数

public ThreadPoolExecutor(
    int corePoolSize,              // 1. 核心线程数
    int maximumPoolSize,           // 2. 最大线程数
    long keepAliveTime,            // 3. 空闲线程存活时间
    TimeUnit unit,                 // 4. 时间单位
    BlockingQueue<Runnable> workQueue,  // 5. 工作队列
    ThreadFactory threadFactory,   // 6. 线程工厂
    RejectedExecutionHandler handler    // 7. 拒绝策略
)

2.2 常用工作队列类型

三、线程池执行流程（五步核心逻辑）

// 伪代码表示执行逻辑
public void execute(Runnable task) {
    // 步骤1：当前线程数 < corePoolSize
    if (workerCount < corePoolSize) {
        addWorker(task, true);  // 新建核心线程执行
        return;
    }
    
    // 步骤2：核心线程已满，尝试放入队列
    if (workQueue.offer(task)) {
        // 放入成功，等待空闲线程取走执行
        return;
    }
    
    // 步骤3：队列已满，尝试创建临时线程
    if (workerCount < maximumPoolSize) {
        addWorker(task, false); // 新建临时线程执行
        return;
    }
    
    // 步骤4：线程数已达最大值，执行拒绝策略
    reject(task);
}

流程图：

提交任务
    │
    ▼
当前线程数 < corePoolSize？ ──Yes──▶ 创建核心线程执行
    │
   No
    │
    ▼
任务能否入队？ ──Yes──▶ 入队等待执行
    │
   No（队列已满）
    │
    ▼
当前线程数 < maximumPoolSize？ ──Yes──▶ 创建临时线程执行
    │
   No
    │
    ▼
执行拒绝策略

四、四种拒绝策略

// 自定义拒绝策略示例
new ThreadPoolExecutor.AbortPolicy()            // 抛异常
new ThreadPoolExecutor.CallerRunsPolicy()       // 调用者执行
new ThreadPoolExecutor.DiscardPolicy()          // 直接丢弃
new ThreadPoolExecutor.DiscardOldestPolicy()    // 丢弃最旧的

五、Executors 四种快捷线程池

⚠️ 开发规范：强制禁止使用 Executors 创建线程池，必须通过 ThreadPoolExecutor 构造函数显式指定参数。

原因：

• FixedThreadPool 和 SingleThreadPool 使用无界队列，可能 OOM
• CachedThreadPool 和 ScheduledThreadPool 允许创建无限数量线程，可能 OOM

// ❌ 错误示范
ExecutorService pool = Executors.newFixedThreadPool(10);

// ✅ 正确示范
ExecutorService pool = new ThreadPoolExecutor(
    10, 20, 60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(1000),
    new ThreadFactoryBuilder().setNameFormat("my-pool-%d").build(),
    new ThreadPoolExecutor.CallerRunsPolicy()
);

六、线程数设置公式

6.1 CPU 密集型任务

定义：大量时间用于计算，很少等待 I/O

线程数 = CPU 核心数 + 1

加 1 是为了在某个线程因缺页中断等原因暂停时，有备用线程顶上，最大化 CPU 利用率。

6.2 I/O 密集型任务

定义：大量时间等待 I/O 操作（网络、磁盘、数据库）

线程数 = CPU 核心数 × 2

更精确的公式：

线程数 = CPU 核心数 × (1 + 平均等待时间 / 平均计算时间)

6.3 混合型任务

将任务拆分为 CPU 密集和 I/O 密集两部分，分别用不同线程池处理。

七、线程池生命周期与优雅关闭

7.1 五种状态

7.2 优雅关闭代码模板

public void shutdownGracefully(ExecutorService pool) {
    pool.shutdown();  // ① 停止接收新任务
    try {
        // ② 等待现有任务完成，最多等待 60 秒
        if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
            pool.shutdownNow();  // ③ 超时则强制关闭
            // ④ 再等待 5 秒，确认是否终止
            if (!pool.awaitTermination(5, TimeUnit.SECONDS)) {
                System.err.println("线程池未能正常终止");
            }
        }
    } catch (InterruptedException e) {
        pool.shutdownNow();  // ⑤ 当前线程被中断，也强制关闭
        Thread.currentThread().interrupt();
    }
}

八、ScheduledThreadPoolExecutor 定时任务线程池

8.1 概述

ScheduledThreadPoolExecutor 继承自 ThreadPoolExecutor，专门用于执行定时和周期性任务，是传统 Timer 的替代品。

8.2 三种核心 API

ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5);

// 1. 延迟执行一次
ScheduledFuture<?> future = scheduler.schedule(
    () -> System.out.println("延迟执行"),
    5, TimeUnit.SECONDS
);

// 2. 固定频率执行（不管上次是否完成）
scheduler.scheduleAtFixedRate(
    () -> System.out.println("固定频率"),
    1,      // 首次延迟 1 秒
    3,      // 每 3 秒执行一次
    TimeUnit.SECONDS
);

// 3. 固定延迟执行（等上次完成后再延迟）
scheduler.scheduleWithFixedDelay(
    () -> System.out.println("固定延迟"),
    1,      // 首次延迟 1 秒
    3,      // 上次完成后等待 3 秒
    TimeUnit.SECONDS
);

8.3 scheduleAtFixedRate vs scheduleWithFixedDelay

scheduleAtFixedRate (周期 = 3秒)
任务执行2秒 → 等待1秒 → 下一轮
任务执行4秒 → 立即触发下一轮（无等待）

scheduleWithFixedDelay (延迟 = 3秒)
任务执行2秒 → 等待3秒 → 下一轮（间隔5秒）
任务执行4秒 → 等待3秒 → 下一轮（间隔7秒）

九、线程池性能监控与调优

9.1 关键监控指标

9.2 监控实现方案

@Component
public class ThreadPoolMonitor {
    
    private final ThreadPoolExecutor executor;
    
    @Scheduled(fixedDelay = 30000)  // 每30秒采集一次
    public void monitor() {
        int activeCount = executor.getActiveCount();
        long completedCount = executor.getCompletedTaskCount();
        int queueSize = executor.getQueue().size();
        int poolSize = executor.getPoolSize();
        long rejectCount = // 自定义记录
        
        log.info("线程池监控 - 活跃:{}, 队列:{}, 池大小:{}, 已完成:{}, 拒绝:{}",
            activeCount, queueSize, poolSize, completedCount, rejectCount);
            
        // 告警判断
        if (queueSize > queueCapacity * 0.7) {
            alert("队列使用率超过70%");
        }
    }
}

9.3 调优策略

十、最佳实践总结

10.1 编码规范

// ✅ 正确：显式创建 ThreadPoolExecutor
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    10,                                    // 核心线程数
    20,                                    // 最大线程数
    60L, TimeUnit.SECONDS,                 // 空闲超时
    new ArrayBlockingQueue<>(1000),        // 有界队列
    new NamedThreadFactory("biz-pool"),    // 自定义线程工厂
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);

// ❌ 错误：使用 Executors 快捷方法
ExecutorService pool = Executors.newFixedThreadPool(10);

10.2 必须设置的内容

• [ ] 有界队列（避免 OOM）
• [ ] 合适的拒绝策略（根据业务选型）
• [ ] 有意义的线程名称（便于排查问题）
• [ ] 监控指标采集（JMX / Micrometer）
• [ ] 优雅关闭逻辑（应用停止时调用）

10.3 参数选择参考

本笔记涵盖了 Java 多线程线程池的核心知识点，建议结合实战加深理解。