线程池源码-线程全部关闭了吗

在前面的文章线程池源码-线程池状态，我们提到线程池的各种状态，以及线程池 shutdown 的流程，但始终有个疑问：shutdown 操作最终能否关闭所有线程？

疑问起源

为什么会有这个问题呢？回顾前面提到的 shutdown 流程。

1. 检查是否有终止线程池的权限，会挨个检查每个线程
2. 修改线程池状态为 SHUTDOWN
3. 终止空闲线程，怎么判断线程是否空闲，通过 tryLock() 尝试获取它的锁，如果成功获取，则证明其为空闲状态，因为执行任务的时候 worker 会给自己上锁，是不可重入锁
4. 调用 onShutdown() 方法，此方法默认没有实现，也是提供给外部的扩展接口
5. 后续的终止操作

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        // 1.检查是否有终止线程池的权限
        checkShutdownAccess();
        // 2.修改线程池状态为 SHUTDOWN
        advanceRunState(SHUTDOWN);
        // 3.终止空闲线程
        interruptIdleWorkers();
        // 4.调用 hook 方法
        onShutdown(); 
    } finally {
        mainLock.unlock();
    }
    // 进行后续的终止操作
    tryTerminate();
}

在调用 tryTerminate() 方法前，空闲线程都被 interruptIdleWorkers() 方法干掉了，还有一种线程活着——正在执行任务的线程。因此我的问题就出现了，shutdown 操作最终能否关闭所有线程？

问题分析

把关闭所有线程的希望寄托在 tryTerminate() 方法上了，我们来看一下代码。

final void tryTerminate() {
  for (;;) {
    int c = ctl.get();
    // 检查是否符合终止操作执行的条件
    // 1.RUNNING 状态的线程池不能 Terminate
    // 2.TIDYING，TERMINATED 状态的线程池不能 Terminate
    // 3.SHUTDOWN 状态，但是任务队列不为空的线程池不能 Terminate
    if (isRunning(c) ||
        runStateAtLeast(c, TIDYING) ||
        (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
      return;
    // 再尝试去中断空闲线程，直到工作线程数量为 0
    if (workerCountOf(c) != 0) { // Eligible to terminate
      interruptIdleWorkers(ONLY_ONE);
      return;
    }
    
    // 进行最后的 terminate 操作，此处代码省略
  }
}

通过分析源码，我们可以想象以下几种场景。

场景一：

假如此时线程状态是 SHUTDOWN，并且任务队列不为空，则直接停止 Terminate 操作，剩下的都是活跃的工作线程，此次 shutdown 操作没有关闭所有线程。

场景二：

假如此时线程状态是 SHUTDOWN，且任务队列为空，线程池还存在线程，则会进一步执行interruptIdleWorkers(ONLY_ONE) 操作，但注意参数是 ONLY_ONE，意味着一次只会干掉一个空闲线程，但 interruptIdleWorkers() 无法干掉正在执行任务的线程，此次 shutdown 操作依然可能没有关闭所有线程。

场景三：

假如此时线程状态是 SHUTDOWN，且任务队列为空，线程池还存在线程，但这几个线程刚执行完任务，都阻塞在了任务获取这一块（从任务队列中取任务采用 queue.take() 阻塞的方式），因为线程池已经拒绝接受新的任务了，如果没有外部中断介入，很有可能就一直阻塞下去了。

这时 interruptIdleWorkers(ONLY_ONE) 中断操作就发挥作用了，queue.take() 是可以响应外部中断信号的。但我仍有疑问——一次只中断一个线程，那其它同样阻塞住的线程怎么办？

我们接着看一下 worker 对象被中断之后的操作，可以看到它调用了 processWorkerExit() 方法，并把 completedAbruptly 作为参数传入，这个参数用来标识线程是否属于异常退出，正常情况下 completedAbruptly = false。

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        while (task != null || (task = getTask()) != null) {
          // 代码省略，假设当前 worker 被中断，退出了 while 循环
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

来看一下 processWorkerExit() 方法，

    private void processWorkerExit(Worker w, boolean completedAbruptly) {
        // 如果 worker 异常退出，还需要在更新一下 workerCount
        if (completedAbruptly) 
            decrementWorkerCount();
        // 做任务统计，把 worker 从列表中移除
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            completedTaskCount += w.completedTasks;
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }
        // 调用 tryTerminate 方法，将中断信号广播出去
        tryTerminate();
        // 后续代码省略
    }

可以发现它也调用了 tryTerminate() 方法，问题似乎有答案了，一个 worker 中断之后会把中断信号广播出去，如此反复，直到所有阻塞的 worker 都被中断，此时 shutdown 操作关闭了所有线程。

总结

通过本篇文章，我们了解了：

• 一次 shutdown() 方法调用后并不能保证关闭所有线程
• Worker 工作线程被中断后，会通过 tryTerminate() 方法将中断信号广播出去

如果觉得文章对你有帮助，欢迎留言点赞。