/**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     */
    public ThreadPoolExecutor(int corePoolSize,
            int maximumPoolSize,
             long keepAliveTime,
            TimeUnit unit,
            BlockingQueue<Runnable> 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;
    }
<pre name="code" class="java">/**
     * Set containing all worker threads in pool. Accessed only when
     * holding mainLock.
     */
    private final HashSet<Worker> workers = new HashSet<Worker>();
 

workers           : 執行緒池 ，Worker是其內部類，沒個Worder含有一個執行緒

corePoolSize  : 執行緒池中最小活動執行緒

maximumPoolSize  :  執行緒池中最大允許執行緒數

workQueue :  快取佇列

keepAliveTime  : 執行緒池中空閒執行緒最大存活時間

TimeUnit : keepAliveTime的單位

threadFactory  :  新建執行緒時工廠類

handle : 處理被拒絕執行緒的處理類

執行過程，如我們上篇的圖，也如上面原始碼中的英文註釋 （至於執行原始碼，有點地方還沒弄通，就不寫分析了）

當新來任務的時候，

1、如果執行緒池小於corePoolSize ， 那麼新建執行緒執行該任務

2、如果執行緒池大於等於corePoolSize ， 那麼就往workQueue中新增

3、如果workQueue滿了且執行緒池小於maximumPoolSize ，那麼就新建執行緒執行任務

4、如果workQueue滿了且執行緒池等於maximumPoolSize  ，那麼就拒絕任務 。

至於快取中的執行緒是如何執行的呢 ？

在每個新建執行緒中都有這麼一段等效程式碼 加在原任務執行結束後：

while(  task = workQueue.poll(keepAliveTime ,TimeUnit ) ) {task.run();}

即執行緒執行任務完後會最大阻塞等待keepAliveTime 時間，直到從快取佇列workQueue中獲取任務 （這段時間內稱執行緒為閒置執行緒）。

獲取到新任務就執行，沒獲取到，那麼執行緒結束。

至於常見的Executors中的幾個構建物件原始碼如下，大家自己理解嘍：

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }//無限快取，有nThreads個執行緒能夠併發執行任務，閒置時間為0 ，即執行完任務瞬間找不到新任務就關閉執行緒

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    } //無限快取，只有一個執行緒順訊的執行放進來的任務,閒置時間為0，即執行完任務瞬間找不到新任務就關閉執行緒

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    } //0快取，每新來個任務都看是否有閒置執行緒，有就使用閒置執行緒執行，否則新建執行緒 。 執行緒最大閒置時間60s

一般情況上訴3個已經滿足，如果大家另有需求就自行構建嘍 。

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(5, 10,
                                    1L, TimeUnit.SECONDS,
                                    new ArrayBlockingQueue<Runnable>(5)));
    }