使用線程池的好處
引用自 http://ifeve.com/java-threadpool/ 的說明：
- 降低資源消耗。通過重復利用已創建的線程降低線程創建和銷毀造成的消耗。
- 提高響應速度。當任務到達時，任務可以不需要的等到線程創建就能立即執行。
- 提高線程的可管理性。線程是稀缺資源，如果無限制的創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一的分配，調優和監控。
Java中的線程池是用ThreadPoolExecutor類來實現的. 本文就結合JDK 1.8對該類的源碼來分析一下這個類內部對於線程的創建, 管理以及后台任務的調度等方面的執行原理。ThreadPoolExecutor結構如下圖：
Executor接口
此接口提供了一種將任務提交與每個任務的運行機制分離的方法，包括線程使用，調度等的詳細信息。該接口中只有execute(Runnable command)方法，用來替代通常創建或啟動線程的方法。例如使用Thread創建線程
Thread thread = new Thread(); thread.start();
使用execute創建運行線程，具體的線程執行會由相應的實現類去執行（jdk默認線程池execute的實現是由ThreadPoolExecutor來實現的）
Thread thread = new Thread(); executor.execute(thread);
ExecutorService接口
ExecutorService接口提供管理終止的方法和可以生成Future的方法，用於跟蹤一個或多個異步任務的進度， 它繼承了Executor接口，同時增加了shutDown()，shutDownNow()，invokeAll()，invokeAny()和submit()等方法。
shutDown() ： 允許之前提交的任務繼續執行（執行完后shutDown，不會再接收新的任務） shutDownNow()：立即停止正在執行的任務 invokeAll()：執行給定的任務，當所有任務完成后返回任務狀態和結果的Futures列表
invokeAny()：執行給定的任務，返回已完成的任務的結果 submit()：提交線程
AbstractExecutorService類
ExecutorService接口的默認實現，同時也是線程池實現類ThreadPoolExecutor的父類，主要看下submit()方法與invokeAll()方法：
submit：
/**不管參數是Callable還是Runable, 執行方法都一樣，生成一個task，然后執行task，execute方法的具體實現在ThreadPoolExecutor中，后續分析**/
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
invokeAll ：
/**代碼很簡單，將給定的任務線程封裝成Future對象，等待所有任務執行完成，統一返回Future對象，如果出現異常，會將未完成的任務取消**/
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException {
if (tasks == null)
throw new NullPointerException();
ArrayList<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
boolean done = false;
try {
for (Callable<T> t : tasks) {
RunnableFuture<T> f = newTaskFor(t);
futures.add(f);
execute(f);
}
for (int i = 0, size = futures.size(); i < size; i++) {
Future<T> f = futures.get(i);
if (!f.isDone()) {
try {
/** 沒有完成，阻塞**/
f.get();
} catch (CancellationException ignore) {
} catch (ExecutionException ignore) {
}
}
}
done = true;
return futures;
} finally {
if (!done)
for (int i = 0, size = futures.size(); i < size; i++)
futures.get(i).cancel(true);
}
}
ThreadPoolExecutor類
在關注ThreadPoolExecutor之前，先來了解下線程的基本狀態信息。
線程總的來說有NEW(初始)、RUNNABLE（運行）、WAITING（等待）、TIME_WAITING（超時等待）、BLOCKED（阻塞）、TERMINATED（終止）6種狀態。
NEW：初始狀態，線程被構建，但是還沒有調用 start 方法
RUNNABLED：運行狀態，JAVA 線程把操作系統中的就緒和運行兩種狀態統一稱為“運行中” BLOCKED：阻塞狀態，表示線程進入等待狀態,也就是線程因為某種原因放棄了 CPU 使用權，阻塞也分為幾種情況 等待阻塞：運行的線程執行 wait 方法，jvm 會把當前線程放入到等待隊列 同步阻塞：運行的線程在獲取對象的同步鎖時，若該同步鎖被其他線程鎖占用了，那么 jvm 會把當前的線程放入到鎖池中 其他阻塞：運行的線程執行 Thread.sleep 或者 Thread.join 方法，或者發出了 I/O請求時，JVM 會把當前線程設置為阻塞狀態，當 sleep 結束、join 線程終止、
io 處理完畢則線程恢復
WAITING：等待，需要主動喚醒 TIME_WAITING：超時等待狀態，超時以后自動返回. TERMINATED：終止狀態，表示當前線程執行完畢
具體的轉化關系如下圖：
對於線程池而言，也有五種種不同的狀態，分別為RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED
RUNNING：運行狀態，可以處理任務，並且接收任務（前提阻塞隊列處於未滿狀態，阻塞隊列一旦滿了，會根據相應的飽和策略進行不同的處理） SHUTDOWN：關閉狀態，不能接收新的任務，但是能處理隊列中的任務（shutdow方法） STOP：停止狀態，不能接收行的任務，不能處理隊列中的任務並且會中斷正在運行的任務（shutdownNow方法） TIDYING：所有的任務都終止了，workCount為0，會進入該狀態，將調用terminated方法進入TERMINATED狀態 TERMINATED：terminated（）方法執行完成
各個狀態之間的轉化關系（借用這里的圖）
ThreadPoolExcecutor類有一些重要的屬性：
corePoolSize：線程池中核心線程的數量 maximumPoolSize：線程池中最大線程的數量 defaultHandler：默認的線程池飽和執行策略，一般是阻塞隊列滿了后且沒有空閑線程，再有任務提交是拋出異常，還是直接丟棄等，默認的策略是拋出異：
ctl：對線程池運行狀態以及線程池中有效線程數進行記錄的一個原子性int變量，主要記錄兩部分：線程池中的有效線程（workerCount）;線程的狀態（runstate）包含運行，shutdown
等狀態。該變量的高3位用來記錄runstate，低29位用來記錄有效線程數（約5億條）（其實這個地方與ReentReadWriteLock中的state變量相似）
COUNT_BITS：workerCount計數位數，低29位
CAPACITY：workerCount的最大值2^29 - 1
飽和策略（內部類）
ThreadPoolExecutor中提供了四種可選擇的飽和策略（拒絕策略），用來處理阻塞隊列已滿且沒有空閑線程，后續新來任務的處理
AbortPolicy：直接拋出異常（默認策略） CallerRunsPolicy：用調用者所在的線程執行任務 CallerRunsPolicy：丟棄隊列中最靠前的任務，執行該任務 DiscardPolicy：直接丟棄
worker類（內部類）
worker類是實現線程池的重要類，它繼承了AQS類並實現了Runnable接口，結構如下：
Worker內部類主要是用來將運行線程封裝，維護運行任務線程中斷狀態的類，該類繼承了AQS類並實現了Runnable接口
變量：
firstTask: 提交的任務線程； thread: worker類封裝后的線程，用來處理任務線程； completeTasks: 完成的任務數；
構造方法：
Worker(Runnable firstTask) {
/**初始化鎖的獲取次數**/
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
獲取鎖、釋放鎖
從Worker類獲取鎖的方式可以看到worker類只會去獲取獨占鎖，也就是說不支持重入的，這也是為什么Worker不直接使用ReentrantLock的原因，ReentrantLock是可重入的；當worker獲取到鎖時表明工作線程正在運行，不允許中斷（可以在runWorker中查看）；
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
構造方法
ThreadPoolExecutor總共有四種構造方法
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,BlockingQueue<Runnable> workQueue)
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory)
/**所有的構造方法調用的都是該方法**/
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;
}
字段說明：
corePoolSize:線程池初始化核心線程數
maximumPoolSize:線程池最大線程數
keepAliveTime:空閑線程存活時間
workQueue:存放任務的隊列（阻塞隊列）
threadFactory:線程池的類型
handler:飽和處理策略
線程池的執行流程
下圖是個人理解的線程池執行的簡單流程（有不對的地方煩請指正）
execute方法
執行給定的任務，可能是用的是新創建的線程，也可能是已存在的線程
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/**獲取ctl，記錄workCount以及runState, 為32**/
int c = ctl.get();
/**判斷線程池中的線程數是否小於核心線程數**/
if (workerCountOf(c) < corePoolSize) {
/**添加一個工作線程線程**/
if (addWorker(command, true))
return;
/**添加失敗重新獲取ctl**/
c = ctl.get();
}
/**線程池是運行狀態，並且線程成功添加到隊列（線程池中線程數大於核心線程或者小於核心線程且添加線程失敗）**/
if (isRunning(c) && workQueue.offer(command)) {
/**重新獲取ctl**/
int recheck = ctl.get();
/**該處的二次檢查是為了防止線程池被shutdown或者上次檢查后有線程死亡**/
/**重新判斷線程池是否是運行狀態，如果不是運行狀態，將成功添加到隊列中的線程從隊列中移除，同時通過對應的飽和策略處理**/
if (! isRunning(recheck) && remove(command))
/**執行拒絕策略**/
reject(command);
/**如果工作線程為0，執行添加工作線程操作**/
else if (workerCountOf(recheck) == 0)
/**添加一個工作線程但不啟動**/
addWorker(null, false);
}
/** 執行到這里說有存在兩種情況
* 1.線程池是running狀態，工作線程數大於核心線程數且阻塞隊列已滿導致添加任務失敗。
* 2.線程池不是工作狀態
**/
else if (!addWorker(command, false))
reject(command);
}
addWorker方法
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
/**獲取線程池的運行狀態**/
int c = ctl.get();
int rs = runStateOf(c);
/** 判斷是否需要添加新的線程（不在添加需要滿足兩個條件：rs >= shutdown; 第二個條件整體為false)
* 1.rs >= SHUTDOWN 即線程池是shutdown、stop、tidying、terminated狀態，表示線程池不在接收新的任務。
*
* 2.rs == SHUTDOWN 即線程池不在接收新的任務；firstTask == null 即提交執行的線程為空；！workQueue.isEmpty() 即阻塞隊列不為空只要三個條件有
* 一個不滿足，則返回false。
* 2.1. 能執行到這里表名rs一定是>=SHUTDOWN的，如果rs不是SHUTDOWN狀態，線程池不會接受新的任務，以及正在處理的任務一會停掉，所以不需要添加新的
* 工作線程。
* 2.2. fistTask為空，沒必要為該任務創建新的工作線程
* 2.3. 阻塞隊列為空，進行該判斷表明rs = SHUTDOWN且阻塞隊列中的任務已經處理完，不會創建新的工作線程
**/
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
/**獲取線程池中的工作線程**/
int wc = workerCountOf(c);
/**判斷工作線程是否超限**/
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
/**通過cas方法添加一個工作線程數**/
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
/**根據firstTask創建一個工作線程**/
w = new Worker(firstTask);
final Thread t = w.thread;
/**firstTask為null只創建，不啟動**/
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int rs = runStateOf(ctl.get());
/**1. 線程池是running狀態
*2. 線程池是shutdown狀態並且firstTask為null
*滿足上面任意一個條件，會去添加工作線程，對於第二個條件來說，不會去接收新的任務，但阻塞隊列可能沒有處理完，可以添加新的工作線程
**/
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
/**線程是否已經啟動**/
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
/**啟動線程**/
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
/**添加工作線程失敗，進行回滾操作
*1.將添加的工作線程從工作線程集合中移除
*2.線程池工作線程數減一
*3.重新執行線程池的terminate狀態轉換
**/
addWorkerFailed(w);
}
return workerStarted;
}
runWorker方法（執行任務）
/**僅僅會在addWorker()成功時調用，內容比較簡單，需要注意三個地方getTask()、beforeExecute()、afterExecute()（后兩個可以自己重寫）**/
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
/** 釋放鎖，對應於worker類構造方法中的setState(-1), 將state狀態恢復為0，允許中斷
* 線程池正在初始化任務線程時，會將鎖的初始值設置為-1，這樣做的目的是禁止執行前對任務進行中斷
**/
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
/**通過getTask（）方法獲取任務**/
while (task != null || (task = getTask()) != null) {
w.lock();
/**判斷線程/線程池是否處於中斷/stop狀態**/
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
/**獲得鎖並運行任務**/
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
/**釋放鎖，任務完成數加1**/
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
getTask方法
private Runnable getTask() {
/**從阻塞隊列中獲取任務是否超時的變量設置**/
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
/**如果線程池不是運行狀態
*1.線程是是否是stop、TIDYING、terminate狀態
*2.阻塞隊列是否為空
*滿足以上條件 1||2，表明線程池不處理任務，不接受新的任務，線程池任務線程數-1
**/
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
/**allowCoreThreadTimeOut為false表示線程池中核心線程數不需要進行超時判斷**/
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
/**獲取任務（都會阻塞）
* 如果設置了核心線程運行超時，或者是線程池中任務線程數多於核心線程數，通過pool設置超時時間獲取任務。
* 沒事設置超時時間，通過take方法獲取任務
**/
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
shutdownNow方法
與shutdown方法相比，多了一個drainQueue清空阻塞隊列的方法，並且所有線程進行中斷操作
/**shutdown方法主要調用了四個方法**/
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
/**如果存在安全管理器，判斷是否有權限interrupt權限**/
checkShutdownAccess();
/**設置線程池運行狀態**/
advanceRunState(STOP);
/**中斷任務線程**/
interruptWorkers();
/**清空阻塞隊列**/
tasks = drainQueue();
} finally {
mainLock.unlock();
}
/**嘗試將線程池設置為terminate狀態**/
tryTerminate();
return tasks;
}
/**該方法是worker類中的方法，直接中斷，與shutdown方法相比，改方法是對所有的任務線程進行中斷操作，
*shutdown方法會去先嘗試獲取鎖，如果獲取鎖成功，表示當前線程正在等待任務，對於這種任務線程進行中斷操作**/
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
tryTerminate方法
final void tryTerminate() {
for (;;) {
int c = ctl.get();
/**1.線程池是否是運行狀態
*2.線程池是都是Tidying、terminate狀態
*3.線程池是否是shutdown狀態，並且阻塞隊列不為空
*滿足上述3個條件任意一個立即返回：
*運行狀態，線程池允許任務的處理以及添加，不能直接轉換到terminate
*shutdown狀態，阻塞隊列不為空，表示還在處理任務，不能直接轉換到terminate
**/
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
/**線程池為shutdown或者stop狀態，且阻塞隊列為空
*如果線程池工作線程數不為0，至少中斷一個工作線程, 此處可能存在getTask獲取任務是一直處於阻塞的任務線程，避免隊列為空，任務線程一直阻塞的情況
**/
if (workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
/**設置為tidying狀態**/
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
terminated();
} finally {
/**設置成terminated狀態**/
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
線程池的監控
getPoolSize() : 獲取當前線程池的工作線程數量 getQueue() : 獲取線程池中阻塞隊列（間接獲取阻塞隊列中任務的數量） getCompletedTaskCount() : 獲取也完成的任務數量 getTaskCount() : 獲取已運行、未運行的任務總數 getLargestPoolSize() ： 線程池線程數最大值 getActiveCount()：當前線程池中正在執行任務的線程數量。 getCorePoolSize() : 線程池核心線程數
常見的線程池（Executors）
Executors是線程池的工廠類，通過Executors可以創建四種不同的線程池 （newFixedThreadPool、newCachedThreadPool、newScheduledThreadPool、newSingleThreadExecutor、newWorkStealingPool（也是一種線程池，但不是通過ThreadPoolExecutor實現，不做討論））
阻塞隊列（引用這里）
SynchronousQueue：newCachedThreadPool
LinkedBlockingQueue(無界隊列)：基於鏈表的阻塞隊列LinkedBlockingQueue。如果使用這種方式，那么線程池中能夠創建的最大線程數就是corePoolSize，
而maximumPoolSize就不會起作用了（后面也會說到）。當線程池中所有的核心線程都是RUNNING狀態時，這時一個新的任務提交就會放入等待隊列中。
newFixedThreadPool使用
ArrayBlockingQueue(有界隊列)：使用該方式可以將線程池的最大線程數量限制為maximumPoolSize，這樣能夠降低資源的消耗，但同時這種方式也使得線程池對線程的調度變
得更困難，因為線程池和隊列的容量都是有限的值，所以要想使線程池處理任務的吞吐率達到一個相對合理的范圍，又想使線程調度相對簡單，並且還要盡可
能的降低線程池對資源的消耗，就需要合理的設置這兩個數量。
1. 如果要想降低系統資源的消耗（包括CPU的使用率，操作系統資源的消耗，上下文環境切換的開銷等）, 可以設置較大的隊列容量和較小的線程池容量,
但這樣也會降低線程處理任務的吞吐量。
2. 如果提交的任務經常發生阻塞，那么可以考慮通過調用 setMaximumPoolSize() 方法來重新設定線程池的容量。
3. 如果隊列的容量設置的較小，通常需要將線程池的容量設置大一點，這樣CPU的使用率會相對的高一些。但如果線程池的容量設置的過大，則在提交的任
務數量太多的情況下，並發量會增加，那么線程之間的調度就是一個要考慮的問題，因為這樣反而有可能降低處理任務的吞吐量。
DelayedWorkQueue ： ScheduledThreadPoolExecutor使用
newFixedThreadPool
固定線程數量的線程池，corePoolSize==maximumPoolSize 1.所有工作線程都在執行任務，新來任務需要在隊列中等待直到有空閑工作線程 2.工作線程在執行任務時被shutdown了，新來任務是會創建一個新的任務線程
newCachedThreadPool
可緩存線程池，corePoolSize==0, maximumPoolSize=Integer.MAX_VALUE 1.沒有核心任務處理線程 2.新來任務是如果有空閑的處理線程，直接使用已有的處理線程，否則創建一個處理線程 3.當超過60s工作線程沒有任務處理，將會被銷毀 該線程池適合處理執行時間短，數量多的任務
newScheduledThreadPool
調度線程池，jdk中單獨一個類實現，初始化對象時設置corePoolSize，maximumPoolSize=Integer.MAX_VALUE 用來設置給定延遲時間后執行
newSingleThreadExecutor
只有一個工作線程來處理任務的線程池，corePoolSize==maximumPoolSize==1