線程池的技術背景
在面向對象編程中，創建和銷毀對象是很費時間的，因為創建一個對象要獲取內存資源或者其它更多資源。在Java中更是如此，虛擬機將試圖跟蹤每一個對象，以便能夠在對象銷毀后進行垃圾回收。
所以提高服務程序效率的一個手段就是盡可能減少創建和銷毀對象的次數，特別是一些很耗資源的對象創建和銷毀。如何利用已有對象來服務就是一個需要解決的關鍵問題，其實這就是一些”池化資源”技術產生的原因。
例如Android中常見到的很多通用組件一般都離不開”池”的概念，如各種圖片加載庫，網絡請求庫，即使Android的消息傳遞機制中的Meaasge當使用Meaasge.obtain()就是使用的Meaasge池中的對象，因此這個概念很重要。本文將介紹的線程池技術同樣符合這一思想。
線程池的優點:
1.重用線程池中的線程,減少因對象創建,銷毀所帶來的性能開銷;
2.能有效的控制線程的最大并發數,提高系統資源利用率,同時避免過多的資源競爭,避免堵塞;
3.能夠多線程進行簡單的管理,使線程的使用簡單、高效。
線程池框架Executor
java中的線程池是通過Executor框架實現的，Executor 框架包括類：Executor，Executors，ExecutorService，ThreadPoolExecutor ，Callable和Future、FutureTask的使用等。
Executor: 所有線程池的接口,只有一個方法。
|
1
2
3
|
public interface Executor { void execute(Runnable command); } |
ExecutorService: 增加Executor的行為，是Executor實現類的最直接接口。
Executors： 提供了一系列工廠方法用于創先線程池，返回的線程池都實現了ExecutorService 接口。
ThreadPoolExecutor：線程池的具體實現類,一般用的各種線程池都是基于這個類實現的。 構造方法如下:
|
1
2
3
4
5
6
7
8
9
10
|
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), defaultHandler);} |
corePoolSize：線程池的核心線程數,線程池中運行的線程數也永遠不會超過 corePoolSize 個,默認情況下可以一直存活。可以通過設置allowCoreThreadTimeOut為True,此時 核心線程數就是0,此時keepAliveTime控制所有線程的超時時間。
maximumPoolSize：線程池允許的最大線程數;
keepAliveTime： 指的是空閑線程結束的超時時間;
unit ：是一個枚舉，表示 keepAliveTime 的單位;
workQueue：表示存放任務的BlockingQueue<Runnable隊列。
BlockingQueue:阻塞隊列（BlockingQueue）是java.util.concurrent下的主要用來控制線程同步的工具。如果BlockQueue是空的,從BlockingQueue取東西的操作將會被阻斷進入等待狀態,直到BlockingQueue進了東西才會被喚醒。同樣,如果BlockingQueue是滿的,任何試圖往里存東西的操作也會被阻斷進入等待狀態,直到BlockingQueue里有空間才會被喚醒繼續操作。 阻塞隊列常用于生產者和消費者的場景，生產者是往隊列里添加元素的線程，消費者是從隊列里拿元素的線程。阻塞隊列就是生產者存放元素的容器，而消費者也只從容器里拿元素。具體的實現類有LinkedBlockingQueue,ArrayBlockingQueued等。一般其內部的都是通過Lock和Condition(顯示鎖（Lock）及Condition的學習與使用)來實現阻塞和喚醒。
線程池的工作過程如下：
線程池剛創建時，里面沒有一個線程。任務隊列是作為參數傳進來的。不過，就算隊列里面有任務，線程池也不會馬上執行它們。
當調用 execute() 方法添加一個任務時，線程池會做如下判斷：
如果正在運行的線程數量小于 corePoolSize，那么馬上創建線程運行這個任務；
如果正在運行的線程數量大于或等于 corePoolSize，那么將這個任務放入隊列；
如果這時候隊列滿了，而且正在運行的線程數量小于 maximumPoolSize，那么還是要創建非核心線程立刻運行這個任務；
如果隊列滿了，而且正在運行的線程數量大于或等于 maximumPoolSize，那么線程池會拋出異常RejectExecutionException。
當一個線程完成任務時，它會從隊列中取下一個任務來執行。
當一個線程無事可做，超過一定的時間（keepAliveTime）時，線程池會判斷，如果當前運行的線程數大于 corePoolSize，那么這個線程就被停掉。所以線程池的所有任務完成后，它最終會收縮到 corePoolSize 的大小。
線程池的創建和使用
生成線程池采用了工具類Executors的靜態方法，以下是幾種常見的線程池。
SingleThreadExecutor：單個后臺線程 (其緩沖隊列是無界的)
|
1
2
3
4
5
6
|
public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService ( new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); } |
創建一個單線程的線程池。這個線程池只有一個核心線程在工作，也就是相當于單線程串行執行所有任務。如果這個唯一的線程因為異常結束，那么會有一個新的線程來替代它。此線程池保證所有任務的執行順序按照任務的提交順序執行。
FixedThreadPool：只有核心線程的線程池,大小固定 (其緩沖隊列是無界的) 。
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
創建固定大小的線程池。每次提交一個任務就創建一個線程，直到線程達到線程池的最大大小。線程池的大小一旦達到最大值就會保持不變，如果某個線程因為執行異常而結束，那么線程池會補充一個新線程。
CachedThreadPool：無界線程池，可以進行自動線程回收。
|
1
2
3
4
5
|
public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0,Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); } |
如果線程池的大小超過了處理任務所需要的線程，那么就會回收部分空閑（60秒不執行任務）的線程，當任務數增加時，此線程池又可以智能的添加新線程來處理任務。此線程池不會對線程池大小做限制，線程池大小完全依賴于操作系統（或者說JVM）能夠創建的最大線程大小。SynchronousQueue是一個是緩沖區為1的阻塞隊列。
ScheduledThreadPool：核心線程池固定，大小無限的線程池。此線程池支持定時以及周期性執行任務的需求。
|
1
2
3
4
5
6
|
public static ExecutorService newScheduledThreadPool(int corePoolSize) { return new ScheduledThreadPool(corePoolSize, Integer.MAX_VALUE, DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS, new DelayedWorkQueue()); } |
創建一個周期性執行任務的線程池。如果閑置,非核心線程池會在DEFAULT_KEEPALIVEMILLIS時間內回收。
線程池最常用的提交任務的方法有兩種：
execute:
ExecutorService.execute(Runnable runable)；
submit:
FutureTask task = ExecutorService.submit(Runnable runnable);
FutureTask<T> task = ExecutorService.submit(Runnable runnable,T Result);
FutureTask<T> task = ExecutorService.submit(Callable<T> callable);
submit(Callable callable)的實現，submit(Runnable runnable)同理。
|
1
2
3
4
5
6
|
public <T> Future<T> submit(Callable<T> task) { if (task == null) throw new NullPointerException(); FutureTask<T> ftask = newTaskFor(task); execute(ftask); return ftask;} |
可以看出submit開啟的是有返回結果的任務，會返回一個FutureTask對象，這樣就能通過get()方法得到結果。submit最終調用的也是execute(Runnable runable)，submit只是將Callable對象或Runnable封裝成一個FutureTask對象，因為FutureTask是個Runnable，所以可以在execute中執行。關于Callable對象和Runnable怎么封裝成FutureTask對象，見Callable和Future、FutureTask的使用。
線程池實現的原理
如果只講線程池的使用，那這篇博客沒有什么大的價值，充其量也就是熟悉Executor相關API的過程。線程池的實現過程沒有用到Synchronized關鍵字，用的都是Volatile,Lock和同步(阻塞)隊列,Atomic相關類，FutureTask等等，因為后者的性能更優。理解的過程可以很好的學習源碼中并發控制的思想。
在開篇提到過線程池的優點是可總結為以下三點：
線程復用
控制最大并發數
管理線程
1.線程復用過程
理解線程復用原理首先應了解線程生命周期。
在線程的生命周期中，它要經過新建(New)、就緒（Runnable）、運行（Running）、阻塞(Blocked)和死亡(Dead)5種狀態。
Thread通過new來新建一個線程，這個過程是是初始化一些線程信息，如線程名，id,線程所屬group等，可以認為只是個普通的對象。調用Thread的start()后Java虛擬機會為其創建方法調用棧和程序計數器，同時將hasBeenStarted為true,之后調用start方法就會有異常。
處于這個狀態中的線程并沒有開始運行，只是表示該線程可以運行了。至于該線程何時開始運行，取決于JVM里線程調度器的調度。當線程獲取cpu后，run()方法會被調用。不要自己去調用Thread的run()方法。之后根據CPU的調度在就緒——運行——阻塞間切換，直到run()方法結束或其他方式停止線程，進入dead狀態。
所以實現線程復用的原理應該就是要保持線程處于存活狀態（就緒，運行或阻塞）。接下來來看下ThreadPoolExecutor是怎么實現線程復用的。
在ThreadPoolExecutor主要Worker類來控制線程的復用?？聪耊orker類簡化后的代碼，這樣方便理解：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
private final class Worker implements Runnable {final Thread thread;Runnable firstTask;Worker(Runnable firstTask) {this.firstTask = firstTask;this.thread = getThreadFactory().newThread(this);}public void run() {runWorker(this);}final void runWorker(Worker w) {Runnable task = w.firstTask;w.firstTask = null;while (task != null || (task = getTask()) != null){task.run();}} |
Worker是一個Runnable，同時擁有一個thread，這個thread就是要開啟的線程，在新建Worker對象時同時新建一個Thread對象，同時將Worker自己作為參數傳入TThread，這樣當Thread的start()方法調用時，運行的實際上是Worker的run()方法，接著到runWorker()中,有個while循環，一直從getTask()里得到Runnable對象，順序執行。getTask()又是怎么得到Runnable對象的呢？
依舊是簡化后的代碼：
|
1
2
3
4
5
6
7
8
9
|
private Runnable getTask() { if(一些特殊情況) { return null; }Runnable r = workQueue.take();return r;} |
這個workQueue就是初始化ThreadPoolExecutor時存放任務的BlockingQueue隊列，這個隊列里的存放的都是將要執行的Runnable任務。因為BlockingQueue是個阻塞隊列，BlockingQueue.take()得到如果是空，則進入等待狀態直到BlockingQueue有新的對象被加入時喚醒阻塞的線程。所以一般情況Thread的run()方法就不會結束,而是不斷執行從workQueue里的Runnable任務，這就達到了線程復用的原理了。
2.控制最大并發數
那Runnable是什么時候放入workQueue？Worker又是什么時候創建，Worker里的Thread的又是什么時候調用start()開啟新線程來執行Worker的run()方法的呢？有上面的分析看出Worker里的runWorker()執行任務時是一個接一個，串行進行的，那并發是怎么體現的呢？
很容易想到是在execute(Runnable runnable)時會做上面的一些任務?？聪耬xecute里是怎么做的。
execute:
簡化后的代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
public void execute(Runnable command) { if (command == null) throw new NullPointerException();int c = ctl.get();// 當前線程數 < corePoolSizeif (workerCountOf(c) < corePoolSize) {// 直接啟動新的線程。if (addWorker(command, true))return;c = ctl.get();}// 活動線程數 >= corePoolSize// runState為RUNNING && 隊列未滿if (isRunning(c) && workQueue.offer(command)) {int recheck = ctl.get();// 再次檢驗是否為RUNNING狀態// 非RUNNING狀態 則從workQueue中移除任務并拒絕if (!isRunning(recheck) && remove(command))reject(command);// 采用線程池指定的策略拒絕任務// 兩種情況：// 1.非RUNNING狀態拒絕新的任務// 2.隊列滿了啟動新的線程失?。╳orkCount > maximumPoolSize）} else if (!addWorker(command, false))reject(command);} |
addWorker:
簡化后的代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
private boolean addWorker(Runnable firstTask, boolean core) {int wc = workerCountOf(c);if (wc >= (core ? corePoolSize : maximumPoolSize)) {return false;}w = new Worker(firstTask);final Thread t = w.thread;t.start();} |
根據代碼再來看上面提到的線程池工作過程中的添加任務的情況：
* 如果正在運行的線程數量小于 corePoolSize，那么馬上創建線程運行這個任務；
* 如果正在運行的線程數量大于或等于 corePoolSize，那么將這個任務放入隊列；
* 如果這時候隊列滿了，而且正在運行的線程數量小于 maximumPoolSize，那么還是要創建非核心線程立刻運行這個任務；
* 如果隊列滿了，而且正在運行的線程數量大于或等于 maximumPoolSize，那么線程池會拋出異常RejectExecutionException。
這就是Android的AsyncTask在并行執行是在超出最大任務數是拋出RejectExecutionException的原因所在，詳見基于最新版本的AsyncTask源碼解讀及AsyncTask的黑暗面
通過addWorker如果成功創建新的線程成功，則通過start()開啟新線程，同時將firstTask作為這個Worker里的run()中執行的第一個任務。
雖然每個Worker的任務是串行處理，但如果創建了多個Worker，因為共用一個workQueue，所以就會并行處理了。
所以根據corePoolSize和maximumPoolSize來控制最大并發數。大致過程可用下圖表示。
上面的講解和圖來可以很好的理解的這個過程。
如果是做Android開發的，并且對Handler原理比較熟悉，你可能會覺得這個圖挺熟悉，其中的一些過程和Handler，Looper，Meaasge使用中，很相似。Handler.send(Message)相當于execute(Runnuble)，Looper中維護的Meaasge隊列相當于BlockingQueue，只不過需要自己通過同步來維護這個隊列，Looper中的loop()函數循環從Meaasge隊列取Meaasge和Worker中的runWork()不斷從BlockingQueue取Runnable是同樣的道理。
3.管理線程
通過線程池可以很好的管理線程的復用，控制并發數，以及銷毀等過程,線程的復用和控制并發上面已經講了，而線程的管理過程已經穿插在其中了，也很好理解。
在ThreadPoolExecutor有個ctl的AtomicInteger變量。通過這一個變量保存了兩個內容：
所有線程的數量 每個線程所處的狀態 其中低29位存線程數，高3位存runState，通過位運算來得到不同的值。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));//得到線程的狀態private static int runStateOf(int c) {return c & ~CAPACITY;}//得到Worker的的數量private static int workerCountOf(int c) {return c & CAPACITY;}// 判斷線程是否在運行private static boolean isRunning(int c) {return c < SHUTDOWN;} |
這里主要通過shutdown和shutdownNow()來分析線程池的關閉過程。首先線程池有五種狀態來控制任務添加與執行。主要介紹以下三種：
RUNNING狀態：線程池正常運行，可以接受新的任務并處理隊列中的任務；
SHUTDOWN狀態：不再接受新的任務，但是會執行隊列中的任務；
STOP狀態：不再接受新任務，不處理隊列中的任務 shutdown這個方法會將runState置為SHUTDOWN，會終止所有空閑的線程，而仍在工作的線程不受影響，所以隊列中的任務人會被執行。
shutdownNow方法將runState置為STOP。和shutdown方法的區別，這個方法會終止所有的線程，所以隊列中的任務也不會被執行了。
總結
通過對ThreadPoolExecutor源碼的分析，從總體上了解了線程池的創建，任務的添加，執行等過程，熟悉這些過程，使用線程池就會更輕松了。
而從中學到的一些對并發控制，以及生產者——消費者模型任務處理的使用，對以后理解或解決其他相關問題會有很大的幫助。比如Android中的Handler機制，而Looper中的Messager隊列用一個BlookQueue來處理同樣是可以的,這寫就是讀源碼的收獲吧。
以上就是對Java 線程池的資料整理，后續繼續補充相關資料，謝謝大家對本站的支持！
