当前位置：首页 > news >正文

面试基础--线程生命周期、线程池（ThreadPoolExecutor 工作原理）

news 来源：原创 2025/6/9 1:09:55

深入解析线程生命周期与线程池（ThreadPoolExecutor）的工作原理：从源码到底层实现

在现代高并发的互联网应用中，多线程编程是提升系统性能的重要手段之一。然而，线程的创建、销毁以及管理成本较高，直接使用线程可能会导致系统资源耗尽。为了解决这一问题，Java 提供了线程池（ThreadPoolExecutor）机制，能够高效地管理线程的生命周期，提升系统性能。本文将深入探讨线程的生命周期、线程池的工作原理，并结合底层源码分析其实现细节。

一、线程的生命周期

在 Java 中，线程的生命周期可以分为以下几个状态：

NEW（新建状态）
线程被创建但尚未启动，此时线程对象已经初始化，但还未调用 start() 方法。
RUNNABLE（可运行状态）
线程调用了 start() 方法后进入 RUNNABLE 状态。此时线程可能正在运行，也可能在等待 CPU 时间片。
BLOCKED（阻塞状态）
线程因为等待锁（如 synchronized 关键字）而进入阻塞状态，直到获取到锁后才能回到 RUNNABLE 状态。
WAITING（等待状态）
线程调用了 wait()、join() 或 LockSupport.park() 等方法，进入无限期等待状态，直到其他线程显式唤醒。
TIMED_WAITING（超时等待状态）
线程调用了 sleep()、wait(timeout) 或 join(timeout) 等方法，进入有限期的等待状态。
TERMINATED（终止状态）
线程执行完毕或因异常退出，进入终止状态。

线程的状态转换可以通过以下代码验证：

Thread thread = new Thread(() -> {
    try {
        Thread.sleep(1000); // TIMED_WAITING
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
System.out.println(thread.getState()); // NEW
thread.start();
System.out.println(thread.getState()); // RUNNABLE
Thread.sleep(500);
System.out.println(thread.getState()); // TIMED_WAITING
thread.join();
System.out.println(thread.getState()); // TERMINATED

二、线程池（ThreadPoolExecutor）的工作原理

线程池的核心思想是复用线程，避免频繁创建和销毁线程带来的性能开销。Java 中的 ThreadPoolExecutor 是线程池的核心实现类，其工作原理可以分为以下几个部分：

1. 核心参数

ThreadPoolExecutor 的构造函数包含以下核心参数：

corePoolSize：核心线程数，即使线程空闲也不会被回收。
maximumPoolSize：最大线程数，当任务队列满时，线程池会创建新线程，直到达到最大线程数。
keepAliveTime：非核心线程的空闲存活时间。
workQueue：任务队列，用于存放待执行的任务。
threadFactory：线程工厂，用于创建线程。
handler：拒绝策略，当任务队列和线程池都满时，如何处理新任务。

2. 任务提交与执行流程

当一个任务提交到线程池时，ThreadPoolExecutor 的执行流程如下：

如果当前线程数小于 corePoolSize，则创建新线程执行任务。
如果线程数已达到 corePoolSize，则将任务放入任务队列（workQueue）。
如果任务队列已满且线程数小于 maximumPoolSize，则创建新线程执行任务。
如果线程数已达到 maximumPoolSize 且任务队列已满，则根据拒绝策略处理任务。

3. 源码分析

以下是 ThreadPoolExecutor 的核心方法 execute() 的源码解析：

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    int c = ctl.get();
    // 1. 如果当前线程数小于 corePoolSize，则创建新线程
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 2. 尝试将任务加入任务队列
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (!isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 3. 如果任务队列已满，尝试创建新线程
    else if (!addWorker(command, false))
        // 4. 如果线程数已达到 maximumPoolSize，执行拒绝策略
        reject(command);
}

ctl：是一个原子整数，用于存储线程池的状态和线程数。
addWorker：用于创建新线程并执行任务。
workQueue.offer：尝试将任务加入任务队列。
reject：执行拒绝策略。

4. 线程池的状态

ThreadPoolExecutor 使用 ctl 的高 3 位表示线程池的状态：

RUNNING：正常运行状态，可以接收新任务并处理队列中的任务。
SHUTDOWN：关闭状态，不再接收新任务，但会处理队列中的任务。
STOP：停止状态，不再接收新任务，也不处理队列中的任务，并中断正在执行的任务。
TIDYING：整理状态，所有任务已终止，线程数为 0。
TERMINATED：终止状态，线程池完全关闭。

三、线程池的底层实现

1. Worker 类

ThreadPoolExecutor 使用 Worker 类封装线程和任务。Worker 实现了 Runnable 接口，其 run() 方法会不断从任务队列中获取任务并执行。

private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
    final Thread thread;
    Runnable firstTask;
    Worker(Runnable firstTask) {
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }
    public void run() {
        runWorker(this);
    }
    // ...
}

2. runWorker 方法

runWorker 方法是线程执行任务的核心逻辑：

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // 允许中断
    boolean completedAbruptly = true;
    try {
        while (task != null || (task = getTask()) != null) {
            w.lock();
            // 如果线程池正在停止，确保线程被中断
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                beforeExecute(wt, task);
                try {
                    task.run();
                    afterExecute(task, null);
                } catch (Throwable ex) {
                    afterExecute(task, ex);
                    throw ex;
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}