【Java】线程池（五）shutdown shutdownnow_scheduledexecutorservice的shutdown会阻塞吗

以ExecutorService的实现类ThreadPoolExecutor为例，看下关于线程池管理方法的实原理：

注意shutdown shutdownnow方法均不是阻塞的，仅仅完成状态的设置，不会等待任务执行完毕。

1.shutdown：调用该方法后会拒绝接收新任务。

    public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(SHUTDOWN);
            interruptIdleWorkers();
            onShutdown(); // hook for ScheduledThreadPoolExecutor
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
    }

调用advanceRunState方法先设置线程池的状态为SHUTDOWN，实现方式为cas自旋，该状态的线程池将不会接收新的任务。为什么不会接收？

Worker是一个Ruannble接口的实现类，其run方法中，有一处调用是不断从任务队列中取任务，每一次poll，都会先检测一遍当前线程池的状态：

            int rs = runStateOf(c);
 
            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

如果是SHUTDOWN并且任务队列为空，则直接返回null，表示不再有新的任务了，worker线程会退出。

设置完状态后，接着调用interruptIdleWorkers方法，中断那些空闲worker线程：

    private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }

其实就是遍历当前工作线程，并依次调用其interrpt方法。为什么需要这步？

因为Worker的run方法里，会不断从任务队列里poll任务，这是一个阻塞操作，如果不打断阻塞poll，则有的空闲的worker会一直等在那里，导致回收不及时。一旦打断阻塞，会结束当前循环，下一次再开始循环时，就可以检测到线程池状态已经变为了SHUTDOWN，所以就可以直接返回了。下面是getTask源码：

private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?
 
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
 
            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
 
            int wc = workerCountOf(c);
 
            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
 
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }
 
            try {
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

最后一步是调用tryTerminate方法，尝试将线程池状态转换为TERMINATED，该状态才是线程池真正终止的标志：

final void tryTerminate() {
        for (;;) {
            int c = ctl.get();
            if (isRunning(c) ||
                runStateAtLeast(c, TIDYING) ||
                (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
                return;
            if (workerCountOf(c) != 0) { // Eligible to terminate
                interruptIdleWorkers(ONLY_ONE);
                return;
            }
 
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                    try {
                        terminated();
                    } finally {
                        ctl.set(ctlOf(TERMINATED, 0));
                        termination.signalAll();
                    }
                    return;
                }
            } finally {
                mainLock.unlock();
            }
            // else retry on failed CAS
        }
    }

该方法也是在一个for循环内部，通过不断尝试来terminate线程池。该方法会在多处被调用，这里看shutdown的情况。

如果当前状态是SHUTDOWN并且workQueue不为空，那么第一层if就直接return了，意味着当前时刻还无法terminate，因为workQueue里还有未执行完成的任务。否则如果当前状态是SHUTDOWN并且workQueue为空了，那么可以通过第一层if判断，这意味着线程池的等待队列里已经没有需要被处理的任务了，只需要等待正在被处理的任务结束即可。所以第二个if就是在判断正在执行任务的worker数目是不是0，如果不是0，就尝试执行interruptIdleWorkers方法，因为一旦执行完了，就可以通过该方法来停止工作线程的运行，完成shutdown。一旦worker数目为0了，就会进入到真正的TERMINATED状态的设置了，在terminate方法调用前，先设置为TIDYING状态，terminate方法调用后，再设置为TERMINATED状态。

为什么要有TIDYING状态而不是直接TERMINATED状态？

因为只要进入到TIDYING状态，说明工作线程数为0并且workQueue为0（如果状态是SHUTDOWN，那么有一个判断可以保证workQueue为0，如果状态是STOP，那么会在shutdownnow方法内清空workQueue），这可以定义为一个标志性的状态，即线程池为空，所以TIDYING状态就是为了表征这个case的。

与TERMINATED的区别是，TERMINATED状态在TIDYING基础上增加了terminate方法的调用。该状态是线程池关闭的真正状态。

总结shutdown方法做了什么事情：

1.设置线程池状态为SHUTDOWN，这将导致线程池不会接收新任务；

2.中断idle的worker线程，回收；

3.尝试terminate；

 

2.shutdownnow：调用该方法后会停止接收新的任务，并且停止当前正在执行的任务，清空workQueue。

    public List<Runnable> shutdownNow() {
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(STOP);
            interruptWorkers();
            tasks = drainQueue();
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
        return tasks;
    }

这里会先调用advanceRunState方法设置线程池状态为STOP。然后调用interruptWorkers方法中断所有worker线程，实现为依次调用interrupt方法打断worker线程：

    private void interruptWorkers() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers)
                w.interruptIfStarted();
        } finally {
            mainLock.unlock();
        }
    }

然后再调用drainQueue方法，将workQueue里等待执行的任务清空并导入到结果集tasks队列里：

    private List<Runnable> drainQueue() {
        BlockingQueue<Runnable> q = workQueue;
        ArrayList<Runnable> taskList = new ArrayList<Runnable>();
        q.drainTo(taskList);
        if (!q.isEmpty()) {
            for (Runnable r : q.toArray(new Runnable[0])) {
                if (q.remove(r))
                    taskList.add(r);
            }
        }
        return taskList;
    }

最后调用tryTerminate方法，尝试将线程池状态转换为TERMINATED。

对应到shutdownnow的情况，线程池状态会是STOP，所以第一个if可以通过，第二个if如果所有任务都有对中断信号的响应处理，那么理论上来说是可以退出的，workQueue数目应该是0了，如果不是，那么也会return，认为无法中断线程池。最后设置TERMINATED状态和之前的逻辑一致。

最后返回workQueue里的任务；

总结shutdownnow做了哪些事情：

1.设置线程池状态为STOP，拒绝接收新任务；

2.打断所有worker线程，回收；

3.清空并返回workQueue里的任务；

4.尝试terminate；

 

3.waitTermination

最后看一个阻塞方法，当调用shutdown方法后，可以再调用该waitTermination方法来等待线程池的退出：

    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))
                    return true;
                if (nanos <= 0)
                    return false;
                nanos = termination.awaitNanos(nanos);
            }
        } finally {
            mainLock.unlock();
        }
    }

循环检测线程池状态是否是TERMINATED。