线程池：从源码解析`keepAliveTime`生效机制

从源码解析keepAliveTime生效机制

在ThreadPoolExecutor中，keepAliveTime的空闲线程回收逻辑集中在**getTask()方法（约320行）和任务队列的阻塞操作**中。以下是关键源码解析：

---

一、回收触发点：getTask()方法

private Runnable getTask() {
    boolean timedOut = false; // 标记上次poll是否超时
    
    for (;;) {
        // ... [状态检查代码省略] ...
        
        int wc = workerCountOf(c);
        // 关键判断1：是否启用超时控制
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
        
        // 关键判断2：回收条件检测（需满足两大条件）
        // 条件A，超过最大线程数或者已被标记为超时
        // 条件B，worker大于1或者队列为空
       // 4种组合，前2种：线程不小心超过最大线程数&&（线程大于1 || 队列为空）
       // 后2种：线程超时 && （线程大于1 || 队列为空），如果只有一个线程是不会回收的
       // 结论就是线程超时，队列没有任务，回收当前线程
       // 线程超时，当前线程数大于1，回收当前线程
        if ((wc > maximumPoolSize || (timed && timedOut))  
            && (wc > 1 || workQueue.isEmpty())) {         
            if (compareAndDecrementWorkerCount(c))
                return null; // ▶️ 触发回收！
        }
        
        try {
            // 核心差异点 ▼▼▼
            Runnable r = timed ?
                // 非核心线程：超时等待（keepAliveTime生效处）
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                // 核心线程：永久阻塞
                workQueue.take();
            
            if (r != null)
                return r;
            timedOut = true; // ◀◀◀ 超时标记点
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

---

二、keepAliveTime生效四步曲

步骤1：设置超时控制模式 (timed标志)

boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

• 当满足以下任一条件时，线程进入超时控制模式：
  1. 当前是非核心线程（wc > corePoolSize）
  2. 启用了核心线程超时（allowCoreThreadTimeOut=true）

步骤2：执行超时等待 (workQueue.poll())

// 如果queue里面任务为0，会等待keepAliveTime纳秒，超时无任务，线程会被回收
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);

• 调用BlockingQueue的poll方法，参数为：
  • keepAliveTime：用户设置的存活时间
  • TimeUnit.NANOSECONDS：纳秒级精度
• 阻塞行为：最多等待keepAliveTime时间，期间：
  • 若有新任务入队 → 立即返回任务对象
  • 若超时无任务 → 返回null

步骤3：标记超时状态 (timedOut=true)

if (r != null) 
    return r;  // 获取到任务
timedOut = true; // ◀◀◀ 超时标记

• 当poll()返回null时，设置timedOut=true
• 此标记将在下一轮循环中触发回收判断

步骤4：触发回收条件 (timed && timedOut)

if ((wc > maximumPoolSize || (timed && timedOut))  // 条件A
    && (wc > 1 || workQueue.isEmpty()))           // 条件B

• 条件A（任一满足）：
  • timed && timedOut：当前是超时控制线程且已超时 ★
  • 线程数超过最大值（非常规情况）
• 条件B（任一满足）：
  • wc > 1：至少还有1个活跃线程
  • workQueue.isEmpty()：任务队列为空
• 同时满足A和B → 通过CAS减少线程计数 → 返回null

---

三、线程回收执行流

当getTask()返回null后：

final void runWorker(Worker w) {
    while (task != null || (task = getTask()) != null) {
        // ... [任务执行] ...
    }
    processWorkerExit(w, false); // ▶️ 回收执行入口
}

在processWorkerExit()中：

private void processWorkerExit(Worker w, boolean completedAbruptly) {
    // 1. 从workers集合移除Worker
    workers.remove(w);
    
    // 2. 统计已完成任务数
    completedTaskCount += w.completedTasks;
    
    // 3. 尝试终止线程池（若满足SHUTDOWN条件）
    tryTerminate();
    
    // 4. 补充新线程（如果需要）
    if (runStateLessThan(c, STOP)) {
        if (!completedAbruptly) {
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            if (workerCountOf(c) >= min)
                return;
        }
        addWorker(null, false);
    }
}

---

四、核心源码设计亮点

1. 双条件保障
   条件A + 条件B 防止过度回收：

   • 避免回收最后一个有任务的线程（当!workQueue.isEmpty()时）
   • 避免回收唯一存活的线程（当wc == 1时）

2. 纳秒级精度控制
   TimeUnit.NANOSECONDS 确保高精度超时：

   // 底层实现（LinkedBlockingQueue为例）
   public E poll(long timeout, TimeUnit unit) throws InterruptedException {
       long nanos = unit.toNanos(timeout); // 转换为纳秒
       // ... [精确到纳秒的等待] ...
   }

3. 无锁化判断
   通过compareAndDecrementWorkerCount(c)实现原子计数更新，避免同步开销。

---

五、线程回收全流程图示

sequenceDiagram
    participant Thread as 工作线程
    participant getTask as getTask()
    participant Queue as 任务队列
    participant Pool as 线程池
    
    Thread->>getTask: 请求新任务
    activate getTask
    
    getTask->>getTask: 检查超时模式(timed)
    alt 超时模式
        getTask->>Queue: poll(keepAliveTime, NANOSECONDS)
        Queue-->>getTask: 等待结果
        alt 超时无任务
            getTask->>getTask: 标记timedOut=true
        else 获取任务
            getTask-->>Thread: 返回任务
        end
    else 永久阻塞
        getTask->>Queue: take()
        Queue-->>getTask: 阻塞直到有任务
    end
    
    alt 满足回收条件
        getTask->>Pool: CAS减少线程计数
        getTask-->>Thread: 返回null
        Thread->>Pool: 调用processWorkerExit()
        Pool->>Pool: 移除Worker对象
        Pool->>JVM: 线程资源待回收
    end
    deactivate getTask

---

六、关键结论

1. 生效位置：
   keepAliveTime在workQueue.poll(keepAliveTime, NANOSECONDS)调用中生效

2. 超时判定：
   当poll()方法在指定时间内未获取任务返回null时，触发超时标记

3. 回收执行：
   超时标记(timedOut=true)结合线程状态判断，导致getTask()返回null，最终触发线程退出

4. 精度保障：
   使用TimeUnit.NANOSECONDS确保时间精度，避免毫秒级误差

通过这种设计，线程池实现了精准的空闲线程回收，在资源利用率和响应速度之间取得平衡。

赏

谢谢你请我吃糖果

支付宝

微信