摘要：所以，并不代表線程池就一定立即就能退出，它也可能必須要等待所有正在執行的任務都執行完成了才能退出。

本文主要分析java.util.concurrent.ThreadPoolExecutor的實現原理，首先看它的構造函數：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

corePoolSize:線程池中穩定保存的線程數（一開始會小于這個數）

maximumPoolSize：線程池中最大線程數

keepAliveTime and unit：大于最小線程數的線程空閑后存活時間

workQueue：用于存放任務的阻塞隊列

threadFactory：用于創建線程的工廠類

handler：當任務隊列滿了且線程數達到了最大時的飽和策略

對于IO密集型任務，線程數一般設為CPU數*2，對于計算密集型任務，線程數一般設為CPU數。

當調用execute方法時：

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    /*
     * Proceed in 3 steps:
     *
     * 1. If fewer than corePoolSize threads are running, try to
     * start a new thread with the given command as its first
     * task.  The call to addWorker atomically checks runState and
     * workerCount, and so prevents false alarms that would add
     * threads when it shouldn"t, by returning false.
     *
     * 2. If a task can be successfully queued, then we still need
     * to double-check whether we should have added a thread
     * (because existing ones died since last checking) or that
     * the pool shut down since entry into this method. So we
     * recheck state and if necessary roll back the enqueuing if
     * stopped, or start a new thread if there are none.
     *
     * 3. If we cannot queue task, then we try to add a new
     * thread.  If it fails, we know we are shut down or saturated
     * and so reject the task.
     */
    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    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);
    }
    else if (!addWorker(command, false))
        reject(command);
}

其流程如圖：

創建線程是通過addWorker創建內部Worker類，其中調用getThreadFactory().newThread(this)來創建執行自己的線程，之后在addWorker中start該線程，執行Worker run方法中的runWorker會不斷的從任務隊列中獲取任務或阻塞，并且每次執行任務前會執行beforeExecute，之后會afterExecute，可以通過重寫beforeExecute方法來給執行線程重命名。

線程池狀態變化如圖：

RUNNING: Accept new tasks and process queued tasks

SHUTDOWN: Don"t accept new tasks, but process queued tasks

STOP: Don"t accept new tasks, don"t process queued tasks, and interrupt in-progress tasks

TIDYING: All tasks have terminated, workerCount is zero, the thread transitioning to state TIDYING will run the terminated() hook method

TERMINATED: terminated() has completed

shutdownNow終止線程的方法是通過調用Thread.interrupt()方法來實現的:

 * 
 If this thread is blocked in an invocation of the {@link
 * Object#wait() wait()}, {@link Object#wait(long) wait(long)}, or {@link
 * Object#wait(long, int) wait(long, int)} methods of the {@link Object}
 * class, or of the {@link #join()}, {@link #join(long)}, {@link
 * #join(long, int)}, {@link #sleep(long)}, or {@link #sleep(long, int)},
 * methods of this class, then its interrupt status will be cleared and it
 * will receive an {@link InterruptedException}.
 *
 * 
 If this thread is blocked in an I/O operation upon an {@link
 * java.nio.channels.InterruptibleChannel InterruptibleChannel}
 * then the channel will be closed, the thread"s interrupt
 * status will be set, and the thread will receive a {@link
 * java.nio.channels.ClosedByInterruptException}.
 *
 * 
 If this thread is blocked in a {@link java.nio.channels.Selector}
 * then the thread"s interrupt status will be set and it will return
 * immediately from the selection operation, possibly with a non-zero
 * value, just as if the selector"s {@link
 * java.nio.channels.Selector#wakeup wakeup} method were invoked.
 *
 * 
 If none of the previous conditions hold then this thread"s interrupt
 * status will be set. 

可以看到如果線程處于正常活動狀態，那么會將該線程的中斷標志設置為true，而無法中斷當前的線程。所以，shutdownNow并不代表線程池就一定立即就能退出，它也可能必須要等待所有正在執行的任務都執行完成了才能退出。