ThreadPoolExecutor 优雅关闭线程池的原理.md

经典关闭线程池代码

ExecutorService executorService = Executors.newFixedThreadPool(10);

executorService.shutdown();
while (!executorService.awaitTermination(10, TimeUnit.SECONDS)) {
    System.out.println("线程池中还有任务在处理");
}

shutdown 做了什么？

先上源码

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        // 线程安全性检查
        checkShutdownAccess();
        // 更新线程池状态为 SHUTDOWN
        advanceRunState(SHUTDOWN);
        // 尝试关闭空闲线程
        interruptIdleWorkers();
        // 空实现
        onShutdown();
    } finally {
        mainLock.unlock();
    }
    // 尝试中止线程池
    tryTerminate();
}

每个方法都有特定的目的，其中 checkShutdownAccess() 和 advanceRunState(SHUTDOWN)比较简单，所以这里不再描述了，而 interruptIdleWorkers() 和 tryTerminate()。

interruptIdleWorkers 做了什么？

关闭当前空闲线程。

onlyOne = true：至多关闭一个空闲worker，可能关闭0个。

onlyOne = false：遍历所有的worker，只要是空闲的worker就关闭。

private void interruptIdleWorkers(boolean onlyOne) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers) {
            Thread t = w.thread;
            // 尝试获得锁，如果获得锁则表明该worker是空闲状态
            if (!t.isInterrupted() && w.tryLock()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                } finally {
                    w.unlock();
                }
            }
            if (onlyOne)
                break;
        }
    } finally {
        mainLock.unlock();
    }
}

w.tryLock()：该方法并不会阻塞，尝试一次如果不成功就返回false，成功则放回true。

在方法 runWorker 中一旦work获得了任务，就会调用调用了 w.lock()，从而倘若 worker 是无锁状态，就是空闲状态。

因此 Worker 之所以继承 AbstractQueuedSynchronizer 实际上是为了达到用无锁，有锁标识worker空闲态与忙碌态，从而方便控制worker的销毁操作。

tryTerminate 做了什么？

这个只是尝试将线程池的状态置为 TERMINATE 态，如果还有worker在执行，则尝试关闭一个worker。

final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        if (isRunning(c) || // 是运行态
            runStateAtLeast(c, TIDYING) ||	// 是 TIDYING 或者 TERMINATE 态
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty())) // SHUTDOWN 态且队列中有任务
            return;
        if (workerCountOf(c) != 0) {
            // 还存在 worker，则尝试关闭一个worker
            interruptIdleWorkers(ONLY_ONE);
            return;
        }

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            // 通过CAS，先置为 TIDYING 态
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                // TIDYING 态
                try {
                    // 空方法
                    terminated();
                } finally {
                    // 最终更新为 TERMINATED 态
                    ctl.set(ctlOf(TERMINATED, 0));
                    termination.signalAll();
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        // else retry on failed CAS
    }
}

通过如下的方法简单做一些过滤。因为状态是从 TIDYING 态往后才到 TERMINATE 态。从这个过滤条件，可以看出如果是STOP态也是会通过的。不过如果线程池到了STOP应该就不会再使用了吧，所以也是不会有什么影响。

if (isRunning(c) || // 是运行态
runStateAtLeast(c, TIDYING) ||	// 是 TIDYING 或者 TERMINATE 态
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty())) // SHUTDOWN 态且队列中有任务
	return;

如果该线程池中有worker，则中止1个worker。通过上面的过滤条件，到了这一步，那么肯定是 SHUTDOWN 态（忽略 STOP 态），并且任务队列已经被处理完成。

if (workerCountOf(c) != 0) {
    // 还存在 worker，则尝试关闭一个worker
    interruptIdleWorkers(ONLY_ONE);
    return;
}

如果该线程池中有多个worker，终止1个worker之后 tryTerminate() 方法就返回了，那么剩下的worker在哪里被处理的呢？（看后面的解答）

假设线程池中的worker都已经关闭并且队列中也没有任务，那么后面的代码将会将线程池状态置为 TERMINATE 态。terminate() 是空实现，用于有需要的自己实现处理，线程池关闭之后的逻辑。

awaitTermination 做了什么

这个方法只是判断当前线程池是否为 TERMINATED 态，如果不是则睡眠指定的时间，如果睡眠中途线程池变为终止态则会被唤醒。这个方法并不会处理线程池的状态变更的操作，纯粹是做状态的判断，所以得要在循环里边做判断。

public boolean awaitTermination(long timeout, TimeUnit unit)
    throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (;;) {
            if (runStateAtLeast(ctl.get(), TERMINATED))	// 是否为 TERMINATED 态
                return true;
            if (nanos <= 0)
                return false;
            nanos = termination.awaitNanos(nanos);	// native 方法，睡一觉
        }
    } finally {
        mainLock.unlock();
    }
}

问题

从 shutdown() 方法源码来看有很大概率没有完全线程池，而awaitTermination() 方法则只是判断线程池状态，并没有关闭线程池状态，那么剩下的worker什么时候促发关闭呢？关键代码逻辑在一个worker被关闭之后，触发了哪些事情。

runWorker

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) {
            w.lock();
            // 省略其他不需要的代码
		   try{
               task.run();
            } finally {
                task = null;
                w.unlock();
            }
        }
        // 用于标识是否是task.run报错
        completedAbruptly = false;
    } finally {
        // 线程关闭的时候调用
        processWorkerExit(w, completedAbruptly);
    }
}

completedAbruptly：用于标识是否是task.run报错，如果值为 TRUE，则是task.run 异常；反之，则没有发生异常

从上面的核心代码来看，当一个worker被关闭之后会调用 processWorkerExit() 方法。看看它做了什么。

processWorkerExit 做了什么

对一个worker退出之后做善后工作，比如统计完成任务数，将线程池的关闭态传播下去，根据条件补充 worker。

private void processWorkerExit(Worker w, boolean completedAbruptly) {
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
        decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks;
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }
	// 如果有worker则尝试关闭一个，否则置为TERMINATE态
    tryTerminate();

    int c = ctl.get();
    if (runStateLessThan(c, STOP)) {
        if (!completedAbruptly) {
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }
        addWorker(null, false);
    }
}

线程池关闭的关键就在于一个worker退出之后，会调用 tryTerminate() 方法，将退出的信号传递下去，这样其他的线程才能够被依次处理，最后线程池会变为 TERMINATE 态。