四種執行緒池內部構造都是來自同一個方法： 

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                    BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory)
 

corePoolSize: 執行緒池中所儲存的核心執行緒數。執行緒池初始化啟動之後，預設是空的，只有當任務來臨之時，才會建立執行緒 處理請求。當然可以使用prestartCoreThread()方法可以使執行緒池初始化之後，立即建立corePoolSize個數的執行緒來等待任務。

maximumPoolSize: 執行緒池中執行緒數能達到的最大值。當然這個引數還與workQueue的使用策略有關，當使用無界佇列(LinkedBlockQueue等)時，本引數無效。corePoolSize和maximumPoolSize的作用是控制執行緒池中實際執行執行緒的數目。例如當新的任務提交到執行緒池時，假設此時執行緒池中執行執行緒的數量為M，當M < corePoolSize時，會新建執行緒來處理任務；如果M>corePoolSize && M < maximumPoolSize時，如果是workQueue是阻塞佇列時，才會建立新的執行緒來完成任務。如果corePoolSize == maximumPoolSize時，則意味著建立了固定大小的執行緒池。如果maximumPoolSize為Integer.MAX_VALUE，則可以理解為該執行緒池適合任意數量的併發任務。

keepAliveTime：當前執行緒池maximumPoolSize > corePoolSize時，終止（maximumPoolSize - corePoolSize）個空閒執行緒的時間。也就是說空閒狀態下，（maximumPoolSize - corePoolSize）個執行緒存活的最長時間。

TimeUnit：keepAliveTime引數的時間單位，可以為毫秒，秒，分。。。

BlockingQueue: 任務佇列，如果當前執行緒池中核心執行緒數達到了corePoolSize時，且當前所有執行緒都屬於活動狀態時，則將新的任務新增到該佇列中。基本上有以下幾個實現：
1) ArrayBlockQueue:基於陣列結構的有界佇列，此佇列按FIFO(first in first out)原則對任務進行排序。如果佇列已滿，新的任務將會被採取拒絕策略對待。
2)LinkedBlockingQueue: 基於連結串列的無界佇列，按FIFO原則排序。因為是無界的，所以不存在滿的情況，此時拒絕策略無效
3) PriorityBlockingQueue：具有優先順序的佇列的有界佇列，可以自定義優先順序，預設為自然排序。

Handler：拒絕策略，當執行緒池和workQueue都滿了的情況下，對新任務採取的處理策略，有四種預設實現：
1) AbortPolicy：拒絕任務，且還丟擲RejectedExecutionException異常，執行緒池預設策略
2) CallerRunPolicy：拒絕新任務進入，如果該執行緒池還沒有被關閉，那麼這個新的任務在執行執行緒中被呼叫
3) DiscardOldestPolicy: 如果執行程式尚未關閉，則位於頭部的任務將會被移除，然後重試執行任務(再次失敗，則重複該過程)，這樣將會導致新的任務將會被執行，而先前的任務將會被移除。
4）DiscardPolicy：沒有新增進去的任務將會被拋棄，也不丟擲異常。基本上為靜默模式。

1、FixedThreadPool      （填充式執行緒池）      只有核心執行緒，核心執行緒數固定，不回收不超時（核心執行緒沒有超時機制），任務佇列長度不限。（排隊吃飯，餐位數量固定）

 public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
    }

2、CachedThreadPool  （快取式執行緒池）      沒有核心執行緒，非核心執行緒隨時建立，數量最大值為Integer.MAX_VALUE。空閒執行緒超時回收（60s）（適合執行大量耗時較小的任務）

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

3、ScheduledThreadPool               核心執行緒數量是固定的，而非核心執行緒是沒有限制的，當非核心執行緒閒置時它會被立即回收，用於執行定時任務和具有固定時期的重複任務，

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }


 public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    } 

4、SingleThreadExecutor  只有一個核心執行緒，確保所有的任務都在同一個執行緒中按順序執行。SingleThreadExecutor的意義在於統一所有外界任務在一個執行緒中，這使得這些任務之間不需要處理執行緒同步的問題。

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

比較如下：