摘要：在程序某些必要的情況下，可以通過線程池的，，，來對線程做一些狀態判定。默認的工廠，只有，為秒，出現情況下，而且線程數超過了核心線程數，會銷毀銷毀線程。線程池最小是，最大是，除非設置了和超時時間，這種情況線程數可能減少到，最大可能是。

    // runState is stored in the high-order bits
    private static final int RUNNING    = -1 << COUNT_BITS;
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    private static final int STOP       =  1 << COUNT_BITS;
    private static final int TIDYING    =  2 << COUNT_BITS;
    private static final int TERMINATED =  3 << COUNT_BITS;

/**
     * Performs blocking or timed wait for a task, depending on
     * current configuration settings, or returns null if this worker
     * must exit because of any of:
     * 1. There are more than maximumPoolSize workers (due to
     *    a call to setMaximumPoolSize).
     * 2. The pool is stopped.
     * 3. The pool is shutdown and the queue is empty.
     * 4. This worker timed out waiting for a task, and timed-out
     *    workers are subject to termination (that is,
     *    {@code allowCoreThreadTimeOut || workerCount > corePoolSize})
     *    both before and after the timed wait.
     *
     * @return task, or null if the worker must exit, in which case
     *         workerCount is decremented
     */
    private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?
        retry:
        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;
            }
            boolean timed;      // Are workers subject to culling?
            for (;;) {
                int wc = workerCountOf(c);
                timed = allowCoreThreadTimeOut || wc > corePoolSize;
                //默認allowCoreThreadTimeOut為false，除非程序指定
                //（1）當沒有超過核心線程時，默認allowCoreThreadTimeOut為false時
                //timed值為false，始終break掉，不會銷毀線程
                //（2）當超過核心線程數，默認allowCoreThreadTimeOut為false時
                //timed值為true，如果超過最大值，則銷毀；如果timeout過，則銷毀
                // 如果allowCoreThreadTimeOut為true，則timed始終為true
                if (wc <= maximumPoolSize && ! (timedOut && timed))
                    break;
                if (compareAndDecrementWorkerCount(c))
                    return null;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
            try {
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

當線程池調用了shutdown方法，線程池的狀態會首先被設置為SHUTDOWN，然后遍歷線程池中所有線程，調用一次interrupt方法，如果在休眠中的線程將會激活，激活后的線程以及調用shutdown方法本身的線程都會嘗試去調用tryTerminate方法，該方法將判定如果線程池中所有記錄的線程數為0，則將線程狀態改為TERMINATED，這個值為3，將大于SHUTDOWN狀態值。

當線程調用了shutdownNow方法后，首先將線程的狀態修改為STOP，這個狀態是大于SHUTDOWN值的，接下來它也會通過中斷激活線程，只是它來的更暴力一些，連加鎖和一些基本判斷都沒有，直接中斷；在調用tryTerminate之前會先清空阻塞隊列中所有的元素，這些元素被組裝為一個List列表作為shutdownNow方法的返回值。換句話說，沒有執行的任務在shutdownNow執行后的返回值中可以得到。在程序某些必要的情況下，可以通過線程池的isTerminating，isTerminated，isStopped，isShutdown來對線程做一些狀態判定。

workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)

當阻塞隊列中沒有任務時，等待時間達到keepAliveTime毫秒值時就會被自動喚醒，而不會永遠地沉睡下去。

keepAliveTime，如果是通過newCachedThreadPool的話，默認是1分鐘超時，如果遇到前面所提到的瞬間沖擊，那么線程池數量將瞬間快速膨脹，而且這些瞬間膨脹的線程的生命周期最少在1分鐘以上。

如果設置了該參數，那么當timeout的時候，就return null，就會跳出循環，回收線程。

if (wc <= maximumPoolSize && ! (timedOut && timed))
                    break;
                if (compareAndDecrementWorkerCount(c))
                    return null;

allowCoreThreadTimeout : 默認情況下核心線程不會退出，可通過將該參數設置為true，讓核心線程也退出。

默認的Executors工廠，只有newCachedThreadPool，timeout為60秒，出現timeout情況下，而且線程數超過了核心線程數，會銷毀銷毀線程。保持在corePoolSize數（如果是cached的，corePoolSize為0）。

   /**
     * Timeout in nanoseconds for idle threads waiting for work.
     * Threads use this timeout when there are more than corePoolSize
     * present or if allowCoreThreadTimeOut. Otherwise they wait
     * forever for new work.
     */
    private volatile long keepAliveTime;
    /**
     * If false (default), core threads stay alive even when idle.
     * If true, core threads use keepAliveTime to time out waiting
     * for work.
     */
    private volatile boolean allowCoreThreadTimeOut;

線程池最小是corePoolSize，最大是maximumPoolSize，除非設置了allowCoreThreadTimeOut和超時時間，這種情況線程數可能減少到0，最大可能是Integer.MAX_VALUE。

Core pool size is the minimum number of workers to keep alive(and not allow to time out etc) unless allowCoreThreadTimeOut is set, in which case the minimum is zero.

/**
     * Creates a thread pool that creates new threads as needed, but
     * will reuse previously constructed threads when they are
     * available.  These pools will typically improve the performance
     * of programs that execute many short-lived asynchronous tasks.
     * Calls to execute will reuse previously constructed
     * threads if available. If no existing thread is available, a new
     * thread will be created and added to the pool. Threads that have
     * not been used for sixty seconds are terminated and removed from
     * the cache. Thus, a pool that remains idle for long enough will
     * not consume any resources. Note that pools with similar
     * properties but different details (for example, timeout parameters)
     * may be created using {@link ThreadPoolExecutor} constructors.
     *
     * @return the newly created thread pool
     */
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue());
    }
    /**
     * Creates a thread pool that creates new threads as needed, but
     * will reuse previously constructed threads when they are
     * available, and uses the provided
     * ThreadFactory to create new threads when needed.
     * @param threadFactory the factory to use when creating new threads
     * @return the newly created thread pool
     * @throws NullPointerException if threadFactory is null
     */
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue(),
                                      threadFactory);
    }

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
        return pollFirst(timeout, unit);
    }

具體如下

public E pollFirst(long timeout, TimeUnit unit)
        throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            E x;
            while ( (x = unlinkFirst()) == null) {
                if (nanos <= 0)
                    return null;
                nanos = notEmpty.awaitNanos(nanos);
            }
            return x;
        } finally {
            lock.unlock();
        }
    }