一、構造方法及其引數
ThreadPoolExecutor位於java.util.concurrent包，有4個帶引數的構造方法。最終被呼叫的構造方法如下。其他構造方法只是提供了預設的ThreadFactory或者RejectedExecutionHandler作為引數。

1 public ThreadPoolExecutor(int corePoolSize,
2 　　　　　　　　　　　　　　　　int maximumPoolSize,
3　　　　　　　　　　　　　　　　 long keepAliveTime,
4　　　　　　　　　　　　　　　　 TimeUnit unit,
5　　　　　　　　　　　　　　　　
 
 BlockingQueue<Runnable> workQueue,
6 　　　　　　　　　　　　　　　　ThreadFactory threadFactory,
7 　　　　　　　　　　　　　　　　RejectedExecutionHandler handler)

構造方法引數解析：

1. int corePoolSize
此引數字面上的意思是核心執行緒的數量。在public void execute(Runnable command)方法中，有以下幾行程式碼：

1 if (workerCountOf(c) < corePoolSize) {
2 if (addWorker(command, true
 
))
3 return;
4 }

其中workerCountOf(c)方法返回的是當前正在執行的執行緒數，addWorker(command,true)方法的功能則是啟動一個新的執行緒以執行command。
可見，當有新任務來到，當前執行的執行緒數少於corePoolSize的時候，ThreadPoolExecutor二話不說就啟動一個新的執行緒來執行這個任務。

2.int maximumPoolSize
最大可執行的執行緒數量。 在addWorker方法中：

 1 private boolean addWorker(Runnable firstTask, boolean core) {
 2
 
 ...
 3 int wc = workerCountOf(c);
 4 if (wc >= CAPACITY ||
 5 wc >= (core ? corePoolSize : maximumPoolSize))
 6 return false;
 7 ...
 8 ...
 9 }
10 addWorker的功能是建立新的執行緒並執行。
11 從上面的程式碼可見，噹噹前執行的執行緒數量大於等於maximumPoolSize時，ThreadPoolExecutor將不會再建立新的執行緒。
12 
13 3.long keepAliveTime
14 private Runnable getTask() {
15 boolean timedOut = false; // Did the last poll() time out?
16 for (;;) {
17 ...
18 int wc = workerCountOf(c);
19 boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
20 ...
21 
22 Runnable r = timed ?
23 workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
24 workQueue.take();
25 ...
26 }
27 }

執行緒池中的執行緒執行完上一個任務之後，將會通過getTask方法獲取下一個任務來執行。即從構造方法中的BlockingQueue<Runnable> workQueue引數--阻塞佇列中獲取。
從上面的程式碼中可知，當timed為true的時候，keepAliveTime才起作用。而timed在兩種情況下才為true：1.當前執行的執行緒數量大於核心執行緒的數量。2.allowCoreThreadTimeOut為true(此變數可通過public void allowCoreThreadTimeOut(boolean value)方法設定),即設定核心執行緒也受等待時長限制。
所以keepAliveTime的作用是，當前執行緒執行完這個任務之後，等待下一個任務到來的最長等待時間。如果在這個時間內沒有新的任務來到，那當前執行緒就會退出。前提是滿足兩個上面說的兩個條件。
4.其他引數
TimeUnit unit : keepAliveTime的時間單位。詳見TimeUnit類說明。

BlockingQueue<Runnable> workQueue : 阻塞佇列，用於存放待執行的任務。

ThreadFactory threadFactory : 為Runnable任務建立執行緒的介面，實現可參照ThreadPoolExecutor的內部類DefaultThreadFactory。
RejectedExecutionHandler handler : java.util.concurrent包下的回撥介面，當用戶傳入的任務無法被接收時，此介面的rejectedExecution方法會被呼叫。

二、主要方法及邏輯
ThreadPoolExecutor的主要邏輯寫在public void execute(Runnable command)方法中:

 1 public void execute(Runnable command) {
 2 if (command == null)
 3 throw new NullPointerException();
 4 int c = ctl.get();
 5 if (workerCountOf(c) < corePoolSize) {
 6 if (addWorker(command, true))
 7 return;
 8 c = ctl.get();
 9 }
10 if (isRunning(c) && workQueue.offer(command)) {
11 int recheck = ctl.get();
12 if (! isRunning(recheck) && remove(command))
13 reject(command);
14 else if (workerCountOf(recheck) == 0)
15 addWorker(null, false);
16 }
17 else if (!addWorker(command, false))
18 reject(command);
19 }

前面說了，workerCountOf(c)方法可以獲取當前正在執行的執行緒數，那我們進到該方法看看:

1 private static int workerCountOf(int c)  { return c & CAPACITY; }
2 private static final int COUNT_BITS = Integer.SIZE - 3;
3 private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

所以整數c的後28位存放著當前執行執行緒的數量？要驗證這個問題，我們先看看c是從哪裡來的：int c = ctl.get(); ，那ctl又是什麼？
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
原來ctl是一個提供原子級操作的整數，關於AtomicInteger大家可以百度下，此處我們就當它是一個整數。其初始值為ctlOf(RUNNINT,0)，這個又是什麼方法？

1 private static int ctlOf(int rs, int wc) { return rs | wc; }
2 private static final int RUNNING    = -1 << COUNT_BITS;
3 private static final int SHUTDOWN   =  0 << COUNT_BITS;
4 private static final int STOP       =  1 << COUNT_BITS;
5 private static final int TIDYING    =  2 << COUNT_BITS;
6 private static final int TERMINATED =  3 << COUNT_BITS;

看到這裡就明瞭了，原來整數c的前4位存放ThreadPoolExecutor的執行狀態，後28位存放執行執行緒的數量。那為什麼要把這兩個數打包到一起呢？這個問題我們後面再看。

所以當workerCountOf(c) < corePoolSize時，我們會進入到addWorker方法：

 1 private boolean addWorker(Runnable firstTask, boolean core) {
 2 retry:
 3 for (;;) {
 4 int c = ctl.get();//當前執行執行緒的數量
 5 int rs = runStateOf(c);//當前執行狀態
 6 
 7 // Check if queue empty only if necessary.
 8 if (rs >= SHUTDOWN &&
 9 ! (rs == SHUTDOWN &&
10 firstTask == null &&
11 ! workQueue.isEmpty())) //當前的執行狀態不為RUNNING，或者在SHUTDOWN狀態下（不接受新任務但是會執行完佇列中的任務）,否則返回false
12 return false;
13 
14 for (;;) {
15 int wc = workerCountOf(c);//再檢查一遍當前執行的執行緒數
16 if (wc >= CAPACITY ||
17 wc >= (core ? corePoolSize : maximumPoolSize))//執行緒的數量不能大於最大容量。如果該任務標記為核心任務，那執行緒的數量不能大於corePoolSize，不然的話不能大於maximunPoolSize，否則返回false
18 return false;
19 if (compareAndIncrementWorkerCount(c))//將執行緒數量加1，如果增加成功，則退出迴圈，執行後面的程式碼。失敗一般都是因為執行緒數不同步。
20 break retry;
21 c = ctl.get(); // Re-read ctl
22 if (runStateOf(c) != rs)//再檢查一遍執行狀態，如果執行狀態改變了，將從外迴圈開頭開始執行，再次確認能否新增任務。
23 continue retry;
24 // else CAS failed due to workerCount change; retry inner loop<pre name="code" class="java">//如果程式執行到這裡，是因為執行緒數加1失敗但是執行狀態沒有發生改變，此時會再執行內迴圈驗證執行緒數。
25 } } 
26 //下面的程式碼功能是建立新的Worker例項 
27 boolean workerStarted = false;//執行緒是否啟動 
28 boolean workerAdded = false;//Worker是否已新增到Set中 
29 Worker w = null; 
30 try { w = new Worker(firstTask); 
31 final Thread t = w.thread;//Worker例項中存放了一個Thread 
32 if (t != null) { 
33 final ReentrantLock mainLock = this.mainLock; 
34 mainLock.lock(); 
35 try { // Recheck while holding lock. 
36 // Back out on ThreadFactory failure or if 
37 // shut down before lock acquired. 
38 int rs = runStateOf(ctl.get()); 
39 if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) {//再次檢查執行狀態，邏輯就不說了，和上面的相同 
40 if (t.isAlive()) // precheck that t is startable 
41 throw new IllegalThreadStateException(); 
42 workers.add(w); 
43 int s = workers.size(); 
44 if (s > largestPoolSize)//這裡應該是統計，沒有實際作用 
45 largestPoolSize = s; workerAdded = true; 
46 } 
47 } finally { 
48 mainLock.unlock(); 
49 }
50 if (workerAdded) { 
51 t.start();//啟動新執行緒 
52 workerStarted = true; 
53 } 
54 } 
55 } finally {
56 if (! workerStarted)//如果啟動執行緒失敗 
57 addWorkerFailed(w); 
58 } 
59 return workerStarted; 
60 }

看來addWorker方法的大致功能就是建立一個新Worker例項，並執行Worker例項中的執行緒。
所以如果addWorker執行成功，則execute方法將直接返回。
如果addWorker執行失敗，即不能為該任務建立一個新的執行緒。那麼execute方法將嘗試把這個方法放到阻塞佇列中。即workQueue.offer(command)。如果offer成功，將再次檢查執行狀態和當前執行的執行緒數量，保證這兩個值沒有在offer期間發生改變。如果當前狀態不是RUNNING，將拒絕這個任務。如果當前執行的執行緒數量為0，則執行addWorker(null, false);。這又是什麼意思？為什麼引數是null？
我們回到addWorker方法看一下。在建立Worker方法的時候，並沒有判斷Runnable是否為null。那它是怎麼執行的？我們再看看Woker類

1 Worker(Runnable firstTask) {
2 setState(-1); // inhibit interrupts until runWorker
3 this.firstTask = firstTask;
4 this.thread = getThreadFactory().newThread(this);
5 }

原來Worker類初始化執行緒變數的時候傳入的Runnable不是我們傳入的引數，而是它自己。我們在看看它自己的run方法。

 1 /** Delegates main run loop to outer runWorker. */
 2 public void run() {
 3 runWorker(this);
 4 }
 5 final void runWorker(Worker w) {
 6         Thread wt = Thread.currentThread();
 7         Runnable task = w.firstTask;//Worker構造方法中的引數在這裡
 8         w.firstTask = null;
 9         w.unlock(); // allow interrupts
10         boolean completedAbruptly = true;
11         try {
12             while (task != null || (task = getTask()) != null) {//當task為null時，嘗試獲取阻塞佇列中的任務
13                 w.lock();
14                 // If pool is stopping, ensure thread is interrupted;
15                 // if not, ensure thread is not interrupted.  This
16                 // requires a recheck in second case to deal with
17                 // shutdownNow race while clearing interrupt
18                 if ((runStateAtLeast(ctl.get(), STOP) ||
19                      (Thread.interrupted() &&
20                       runStateAtLeast(ctl.get(), STOP))) &&
21                     !wt.isInterrupted())
22                     wt.interrupt();
23                 try {
24                     beforeExecute(wt, task);
25                     Throwable thrown = null;
26                     try {
27                         task.run();//執行任務
28                     } ... finally {
29                         afterExecute(task, thrown);
30                     }
31                 } finally {
32                     task = null;
33                     w.completedTasks++;
34                     w.unlock();
35                 }
36             }
37             completedAbruptly = false;
38         } finally {
39             processWorkerExit(w, completedAbruptly);
40         }
41     }
42 private Runnable getTask() {
43         boolean timedOut = false; // Did the last poll() time out?
44         for (;;) {
45             int c = ctl.get();
46             int rs = runStateOf(c);
47             // Check if queue empty only if necessary.
48             if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
49                 decrementWorkerCount();
50                 return null;
51             }
52             int wc = workerCountOf(c);
53             // Are workers subject to culling?
54             boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
55             if ((wc > maximumPoolSize || (timed && timedOut))
56                 && (wc > 1 || workQueue.isEmpty())) {
57                 if (compareAndDecrementWorkerCount(c))
58                     return null;
59                 continue;
60             }
61             try {
62                 Runnable r = timed ?
63                     workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
64                     workQueue.take();
65                 if (r != null)
66                     return r;//這裡返回阻塞佇列的Runnable。此處邏輯在前面的keepAliveTime中已講過。
67                 timedOut = true;
68             } catch (InterruptedException retry) {
69                 timedOut = false;
70             }
71         }
72     }

到這裡就明白了。噹噹前執行的執行緒數為0時，呼叫addWorker(null,false)時，將建立一個新的執行緒去取阻塞佇列中的任務來執行。

最後，execute方法中，如果呼叫offer在阻塞佇列存入任務失敗，將呼叫addWorker(command, false)嘗試啟動一個非核心執行緒來執行任務。如果啟動失敗，此任務將被拒絕。

3.總結
所以，ThreadPoolExecutor的主要邏輯是，當用戶呼叫execute(Runnable command) ，大致邏輯如下(注意是大致邏輯，程式碼中的邏輯更復雜更詳細)：
1.檢視當前執行狀態，如果不是RUNNING狀態，將直接拒絕新任務。否則進入步驟2。
2.檢視當前執行執行緒的數量，如果數量少於核心執行緒數，將直接建立新的執行緒執行該任務。否則進入步驟3。
3.將該任務新增到阻塞佇列，等待核心執行緒執行完上一個任務再來獲取。如果新增到阻塞佇列失敗，進入步驟4。
4.嘗試建立一個非核心執行緒執行該任務，前提是執行緒的數量少於等於最大執行緒數。如果失敗，拒絕該任務。

所以使用ThreadPoolExecutor需要注意下面幾點：
1.allowCoreThreadTimeOut預設為false，如果不設定為true，那已被建立的少於等於核心執行緒數量的執行緒，將一直存在，處於執行狀態或者阻塞在workQueue.take()中。
2.當前執行的執行緒數等於核心執行緒數了，任務才會被加入佇列，當佇列滿了，才會建立非核心執行緒。所以如果使用LinkedBlockingQueue，那麼佇列將不會滿，非核心執行緒不會被建立。
3.如果佇列滿了，當前執行的執行緒數也達到最大執行緒數了，那麼新增的任務將被拒絕，即使並沒有發生任何錯誤。所以應該做好被拒絕任務的處理工作。