Java線程池

標籤：java線程池

本文大部分內容轉自http://www.cnblogs.com/yydcdut/p/3890893.html

1.Java線程池基本原理

線程池基本原理是：系統先啟動若干數量的線程，並讓這些線程處於睡眠狀態，當有新任務時，就會喚醒線程池中的某一個睡眠線程，讓它來處理這個任務。當處理完這個任務後，線程又處於睡眠狀態。

Java 中，線程池的主要組成部分是工作者線程，這種類型的線程獨立於它執行的Runnable和Callable任務存在，並且經常用於執行多個任務。

工作者線程和普通線程不同之處在於run方法的不同。普通線程在完成線程應該執行的代碼後，自然退出，線程結束，Java虛擬機器回收分配給線程的資源，線程對象被記憶體回收期收回。而構成線程池的工作者線程是可重用線程，它的run方法執行完某一任務的特定代碼後，使自己進入睡眠狀態而不是結束線程。

2.線程池的作用

線程池作用就是限制系統中執行線程的數量。
根據系統的環境情況，可以自動或手動設定線程數量，達到啟動並執行最佳效果；少了浪費了系統資源，多了造成系統擁擠效率不高。用線程池控制線程數量，其他線程排隊等候。一個任務執行完畢，再從隊列的中取最前面的任務開始執行。若隊列中沒有等待進程，線程池的這一資源處於等待。當一個新任務需要運行時，如果線程池中有等待的背景工作執行緒，就可以開始運行了；否則進入等待隊列。

3.為什麼要用線程

①減少了建立和銷毀線程的次數，每個背景工作執行緒都可以被重複利用，可執行多個任務。
②可以根據系統的承受能力，調整線程池中工作線線程的數目，防止因為消耗過多的記憶體，而把伺服器累趴下(每個線程需要大約1MB記憶體，線程開的越多，消耗的記憶體也就越大，最後死機)。

4.Concurrent包中幾個重要的類

Java裡麵線程池的頂級介面是Executor，但是嚴格意義上講Executor並不是一個線程池，而只是一個執行線程的工具。真正的線程池介面是ExecutorService。

比較重要的幾個類：

ExecutorService	真正的線程池介面
ScheduledExecutorService	和Timer/TimerTask類似，解決那些需要任務重複執行的問題
ThreadPoolExecutor	ExecutorService的預設實現
ScheduledThreadPoolExecutor	繼承ThreadPoolExecutor的ScheduledExecutorService介面實現，週期性任務調度的類實現

類之間的架構圖

ThreadPoolExecutor詳解

hreadPoolExecutor的完整構造方法的簽名是：
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) .
參數解釋：

corePoolSize - 池中所儲存的線程數，包括空閑線程。
maximumPoolSize-池中允許的最大線程數。
keepAliveTime - 當線程數大於核心時，此為終止前多餘的空閑線程等待新任務的最長時間。
unit - keepAliveTime 參數的時間單位。
workQueue - 執行前用於保持任務的隊列。此隊列僅保持由 execute方法提交的 Runnable任務。
threadFactory - 執行程式建立新線程時使用的工廠。
handler - 由於超出線程範圍和隊列容量而使執行被阻塞時所使用的處理常式。
ThreadPoolExecutor是Executors類的底層實現。


在JDK協助文檔中，有如此一段話：
“強烈建議程式員使用較為方便的ExecutorsFactory 方法Executors.newCachedThreadPool()（無界線程池，可以進行自動線程回收）、Executors.newFixedThreadPool(int)（固定大小線程池）Executors.newSingleThreadExecutor()（單個後台線程），它們均為大多數使用情境預定義了設定。”

下面介紹幾個類的源碼：

ExecutorService newFixedThreadPool (int nThreads):固定大小線程池

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

可以看到，corePoolSize和maximumPoolSize的大小是一樣的（實際上，後面會介紹，如果使用無界queue的話maximumPoolSize參數是沒有意義的），keepAliveTime和unit的設值表名什嗎？——就是該實現不想keep alive！最後的BlockingQueue選擇了LinkedBlockingQueue，該LinkedBlockingQueue有一個特點，它是無界的。

ExecutorService newSingleThreadExecutor()：單線程

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

ExecutorService newCachedThreadPool()：無界線程池，可以進行自動線程回收

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

首先是無界的線程池，所以我們可以發現maximumPoolSize為Integer.MAX_VALUE。其次BlockingQueue的選擇上使用SynchronousQueue。可能對於該BlockingQueue有些陌生，簡單說：該BlockingQueue中，每個插入操作必須等待另一個線程的對應移除操作。

先從BlockingQueue<Runnable> workQueue這個入參開始說起。在JDK中，其實已經說得很清楚了，一共有三種類型的queue。
所有BlockingQueue 都可用於傳輸和保持提交的任務。可以使用此隊列與池大小進行互動：
如果啟動並執行線程少於 corePoolSize，則 Executor始終首選添加新的線程，而不進行排隊。（如果當前啟動並執行線程小於corePoolSize，則任務根本不會存放，添加到queue中，而是直接抄傢伙（thread）開始運行）
如果啟動並執行線程等於或多於 corePoolSize，則 Executor始終首選將請求排入佇列，而不添加新的線程。
如果無法將請求排入佇列，則建立新的線程，除非建立此線程超出 maximumPoolSize，在這種情況下，任務將被拒絕。

queue的三種類型

排隊有三種通用策略：
直接提交
工作隊列的預設選項是 SynchronousQueue，它將任務直接提交給線程而不保持它們。在此，如果不存在可用於立即運行任務的線程，則試圖把任務排入佇列將失敗，因此會構造一個新的線程。此策略可以避免在處理可能具有內部依賴性的請求集時出現鎖。直接提交通常要求無界maximumPoolSizes 以避免拒絕新提交的任務。當命令以超過隊列所能處理的平均數連續到達時，此策略允許無界線程具有增長的可能性。

無界隊列
使用無界隊列（例如，不具有預定義容量的 LinkedBlockingQueue）將導致在所有 corePoolSize 線程都忙時新任務在隊列中等待。這樣，建立的線程就不會超過 corePoolSize。（因此，maximumPoolSize的值也就無效了。）當每個任務完全獨立於其他任務，即任務執行互不影響時，適合於使用無界隊列；例如，在 Web頁伺服器中。這種排隊可用於處理瞬態突發請求，當命令以超過隊列所能處理的平均數連續到達時，此策略允許無界線程具有增長的可能性。

有界隊列
當使用有限的 maximumPoolSizes時，有界隊列（如 ArrayBlockingQueue）有助於防止資源耗盡，但是可能較難調整和控制。隊列大小和最大池大小可能需要相互折衷：使用大型隊列和小型池可以最大限度地降低 CPU 使用率、作業系統資源和環境切換開銷，但是可能導致人工降低輸送量。如果任務頻繁阻塞（例如，如果它們是 I/O邊界），則系統可能為超過您許可的更多線程安排時間。使用小型隊列通常要求較大的池大小，CPU使用率較高，但是可能遇到不可接受的調度開銷，這樣也會降低輸送量。

BlockingQueue的選擇 

①使用直接提交策略，也即SynchronousQueue
首先SynchronousQueue是無界的，也就是說他存數任務的能力是沒有限制的，但是由於該Queue本身的特性，在某次添加元素後必須等待其他線程取走後才能繼續添加。在這裡不是核心線程便是新建立的線程，但是我們試想一樣下，下面的情境。
我們使用一下參數構造ThreadPoolExecutor：

new ThreadPoolExecutor(                    2, 3, 30, TimeUnit.SECONDS,                     new  SynchronousQueue<Runnable>(),                    new RecorderThreadFactory("CookieRecorderPool"),                new ThreadPoolExecutor.CallerRunsPolicy());

當核心線程已經有2個正在運行.
1、此時繼續來了一個任務（A），根據前面介紹的“如果啟動並執行線程等於或多於 corePoolSize，則 Executor始終首選將請求排入佇列，而不添加新的線程。”,所以A被添加到queue中。
2、又來了一個任務（B），且核心2個線程還沒有忙完，OK，接下來首先嘗試1中描述，但是由於使用的SynchronousQueue，所以一定無法加入進去。
3、此時便滿足了上面提到的“如果無法將請求排入佇列，則建立新的線程，除非建立此線程超出maximumPoolSize，在這種情況下，任務將被拒絕。”，所以必然會建立一個線程來運行這個任務。
4、暫時還可以，但是如果這三個任務都還沒完成，連續來了兩個任務，第一個添加入queue中，後一個呢？queue中無法插入，而線程數達到了maximumPoolSize，所以只好執行異常策略了。
所以在使用SynchronousQueue通常要求maximumPoolSize是無界的，這樣就可以避免上述情況發生（如果希望限制就直接使用有界隊列）。對於使用SynchronousQueue的作用jdk中寫的很清楚：此策略可以避免在處理可能具有內部依賴性的請求集時出現鎖。
什麼意思？如果你的任務A1，A2有內部關聯，A1需要先運行，那麼先提交A1，再提交A2，當使用SynchronousQueue我們可以保證，A1必定先被執行，在A1麼有被執行前，A2不可能添加入queue中。

②使用無界隊列策略，即LinkedBlockingQueue
這個是最為複雜的使用，所以JDK不推薦使用也有些道理。與上面的相比，最大的特點便是可以防止資源耗盡的情況發生。
舉例來說，請看如下構造方法：

new ThreadPoolExecutor(    2, 4, 30, TimeUnit.SECONDS,    new ArrayBlockingQueue<Runnable>(2),    new RecorderThreadFactory("CookieRecorderPool"),    new ThreadPoolExecutor.CallerRunsPolicy());

假設，所有的任務都永遠無法執行完。
對於首先來的A,B來說直接運行，接下來，如果來了C,D，他們會被放到queue中，如果接下來再來E,F，則增加線程運行E，F。但是如果再來任務，隊列無法再接受了，線程數也到達最大的限制了，所以就會使用拒絕策略來處理。

keepAliveTime

jdk中的解釋是：當線程數大於核心時，此為終止前多餘的空閑線程等待新任務的最長時間。
有點拗口，其實這個不難理解，在使用了“池”的應用中，大多都有類似的參數需要配置。比如資料庫連接池，DBCP中的maxIdle，minIdle參數。
什麼意思？接著上面的解釋，後來向老闆派來的工人始終是“借來的”，俗話說“有借就有還”，但這裡的問題就是什麼時候還了，如果借來的工人剛完成一個任務就還回去，後來發現任務還有，那豈不是又要去借？這一來一往，老闆肯定頭也大死了。
合理的策略：既然借了，那就多借一會兒。直到“某一段”時間後，發現再也用不到這些工人時，便可以還回去了。這裡的某一段時間便是keepAliveTime的含義，TimeUnit為keepAliveTime值的度量。

RejectedExecutionHandler

另一種情況便是，即使向老闆借了工人，但是任務還是繼續過來，還是忙不過來，這時整個隊伍只好拒絕接受了。
RejectedExecutionHandler介面提供了對於拒絕任務的處理的自定方法的機會。在ThreadPoolExecutor中已經預設包含了4中策略，因為源碼非常簡單，這裡直接貼出來。

① CallerRunsPolicy：線程調用運行該任務的 execute 本身。此策略提供簡單的反饋控制機制，能夠減緩新任務的提交速度。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {           if (!e.isShutdown()) {               r.run();           }       }

這個策略顯然不想放棄執行任務。但是由於池中已經沒有任何資源了，那麼就直接使用調用該execute的線程本身來執行。

② AbortPolicy：處理常式遭到拒絕將拋出運行時RejectedExecutionException

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {           throw new RejectedExecutionException();       }

這種策略直接拋出異常，丟棄任務。

③ DiscardPolicy：不能執行的任務將被刪除

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {       }

這種策略和AbortPolicy幾乎一樣，也是丟棄任務，只不過他不拋出異常。

④ DiscardOldestPolicy：如果執行程式尚未關閉，則位於工作隊列頭部的任務將被刪除，然後重試執行程式（如果再次失敗，則重複此過程）

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {           if (!e.isShutdown()) {               e.getQueue().poll();               e.execute(r);           }       }

該策略就稍微複雜一些，在pool沒有關閉的前提下首先丟掉緩衝在隊列中的最早的任務，然後重新嘗試運行該任務。這個策略需要適當小心。

設想:如果其他線程都還在運行，那麼新來任務踢掉舊任務，緩衝在queue中，再來一個任務又會踢掉queue中最老任務。

小結

keepAliveTime和maximumPoolSize及BlockingQueue的類型均有關係。如果BlockingQueue是無界的，那麼永遠不會觸發maximumPoolSize，自然keepAliveTime也就沒有了意義。
反之，如果核心數較小，有界BlockingQueue數值又較小，同時keepAliveTime又設的很小，如果任務頻繁，那麼系統就會頻繁的申請回收線程。

5.Java線程池用法樣本

①newSingleThreadExecutor

MyThread.java

public class MyThread extends Thread {@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + "正在執行。。。");}}

TestSingleThreadExecutor.java

public class TestSingleThreadExecutor {public static void main(String[] args) {// 建立一個可重用固定線程數的線程池ExecutorService pool = Executors.newSingleThreadExecutor();// 建立實現了Runnable介面的對象Thread t1 = new MyThread();Thread t2 = new MyThread();Thread t3 = new MyThread();Thread t4 = new MyThread();Thread t5 = new MyThread();// 將線程放入池中執行pool.execute(t1);pool.execute(t2);pool.execute(t3);pool.execute(t4);pool.execute(t5);// 關閉線程池pool.shutdown();}}

輸出結果：

pool-1-thread-1正在執行。。。pool-1-thread-1正在執行。。。pool-1-thread-1正在執行。。。pool-1-thread-1正在執行。。。pool-1-thread-1正在執行。。。

②newFixedThreadPool
TestFixedThreadPool.java

public class TestFixedThreadPool {public static void main(String[] args) {// 建立一個可重用固定線程數的線程池ExecutorService pool = Executors.newFixedThreadPool(5);// 建立實現了Runnable介面的對象Thread t1 = new MyThread();Thread t2 = new MyThread();Thread t3 = new MyThread();Thread t4 = new MyThread();Thread t5 = new MyThread();// 將線程放入池中執行pool.execute(t1);pool.execute(t2);pool.execute(t3);pool.execute(t4);pool.execute(t5);// 關閉線程池pool.shutdown();}}

輸出結果：

pool-1-thread-2正在執行。。。pool-1-thread-4正在執行。。。pool-1-thread-1正在執行。。。pool-1-thread-3正在執行。。。pool-1-thread-5正在執行。。。

③newCachedThreadPool

TestCachedThreadPool.java

public class TestCachedThreadPool {public static void main(String[] args) {ExecutorService pool = Executors.newCachedThreadPool();// 建立實現了Runnable介面的對象Thread t1 = new MyThread();Thread t2 = new MyThread();Thread t3 = new MyThread();Thread t4 = new MyThread();Thread t5 = new MyThread();// 將線程放入池中執行pool.execute(t1);pool.execute(t2);pool.execute(t3);pool.execute(t4);pool.execute(t5);// 關閉線程池pool.shutdown();}}

輸出結果：

pool-1-thread-2正在執行。。。pool-1-thread-4正在執行。。。pool-1-thread-5正在執行。。。pool-1-thread-1正在執行。。。pool-1-thread-3正在執行。。。

④newScheduledThreadPool

TestScheduledThreadPoolExecutor.java

public class TestScheduledThreadPoolExecutor {public static void main(String[] args) {ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(10);exec.scheduleAtFixedRate(new MyThread(), 0, 10, TimeUnit.MILLISECONDS);}}