說說Java線程池

文章目錄

• 線程池的作用
• 為什麼要用線程池
• 線程池的原理
• java線程池
• ThreadPoolExecutor
• Executors

線程池的作用

線程池作用就是限制系統中執行線程的數量。

根據系統的環境情況，可以自動或手動設定線程數量，達到啟動並執行最佳效果；如果線程少了會浪費系統資源，多了又會造成系統擁擠效率不高。用線程池控制線程數量，使得其他線程排隊等候。一個任務執行完畢，再從隊列的中取最前面的任務開始執行。若隊列中沒有任務等待進程，則線程池中的線程處於等待。

為什麼要用線程池

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

線程池的原理

其實線程池的原理很簡單，類似於作業系統中的緩衝區的概念，它的流程如下：先啟動若干數量的線程，並讓這些線程都處於睡眠狀態，當用戶端有一個新請求時，就會喚醒線程池中的某一個睡眠線程，讓它來處理用戶端的這個請求，當處理完這個請求後，線程又處於睡眠狀態。

java線程池

java關於線程池的主要內容有：
介面：Executor、ExecutorService、ScheduledExecutorService、CompletionService
類：Executors、AbstractExecutorService、ThreadPoolExecutor、ScheduledThreadPoolExecutor、ExecutorCompletionService

只介紹重要的兩個類Executors和ThreadPoolExecutor

ThreadPoolExecutor

public 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 - 由於超出線程範圍和隊列容量而使執行被阻塞時所使用的處理常式。

拋出：

● IllegalArgumentException - 如果 corePoolSize 或 keepAliveTime 小於 0，或者 maximumPoolSize 小於等於 0，或者 corePoolSize 大於 maximumPoolSize。
● NullPointerException - 如果 workQueue、threadFactory 或 handler 為 null。 
● unit可選的參數為java.util.concurrent.TimeUnit中的幾個靜態屬性：NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS
● workQueue我常用的是：java.util.concurrent.ArrayBlockingQueue
● handler有四個選擇：

1. ThreadPoolExecutor.AbortPolicy()

拋出java.util.concurrent.RejectedExecutionException異常

2. ThreadPoolExecutor.CallerRunsPolicy()

重試添加當前的任務，他會自動重複調用execute()方法

3. ThreadPoolExecutor.DiscardOldestPolicy()

拋棄舊的任務

4. ThreadPoolExecutor.DiscardPolicy()

拋棄當前的任務
一個任務通過execute(Runnable)方法被添加到線程池，任務就是一個 Runnable類型的對象，任務的執行方法就是 Runnable類型對象的run()方法。
當一個任務通過execute(Runnable)方法欲添加到線程池時，會有以下：
1. 如果此時線程池中的數量小於corePoolSize，即使線程池中的線程都處於空閑狀態，也要建立新的線程來處理被添加的任務。
2. 如果此時線程池中的數量等於 corePoolSize，但是緩衝隊列 workQueue未滿，那麼任務被放入緩衝隊列。
3. 如果此時線程池中的數量大於corePoolSize，緩衝隊列workQueue滿，並且線程池中的數量小於maximumPoolSize，建新的線程來處理被添加的任務。
4. 如果此時線程池中的數量大於corePoolSize，緩衝隊列workQueue滿，並且線程池中的數量等於maximumPoolSize，那麼通過 handler所指定的策略來處理此任務。也就是處理任務的優先順序為：核心線程corePoolSize、任務隊列workQueue、最大線程maximumPoolSize，如果三者都滿了，使用handler處理被拒絕的任務。
5. 當線程池中的線程數量大於 corePoolSize時，如果某線程空閑時間超過keepAliveTime，線程將被終止。這樣，線程池可以動態調整池中的線程數。

Executors

雖然通過ThreadPoolExecutor可以完成線程池的建立，但是建立過程複雜繁瑣，要求程式員對於每一個參數的意義都很清楚，對於建立的流程也必須十分瞭解，而通過Executors則可以大大簡化線程池的建立過程，因此強烈建議程式員使用較為方便的 Executors Factory 方法 Executors.newCachedThreadPool()（無界線程池，可以進行自動線程回收）、Executors.newFixedThreadPool(int)（固定大小線程池）和 Executors.newSingleThreadExecutor()（單個後台線程），它們均為大多數使用情境預定義了設定。否則，在手動設定和調整此類時，使用以下指導：

核心和最大池大小

ThreadPoolExecutor 將根據 corePoolSize（參見 getCorePoolSize()）和 maximumPoolSize（參見 getMaximumPoolSize()）設定的邊界自動調整池大小。當新任務在方法 execute(java.lang.Runnable) 中提交時，如果啟動並執行線程少於 corePoolSize，則建立新線程來處理請求，即使其他輔助線程是閒置。如果啟動並執行線程多於 corePoolSize 而少於 maximumPoolSize，則僅當隊列滿時才建立新線程。如果設定的
corePoolSize 和 maximumPoolSize 相同，則建立了固定大小的線程池。如果將 maximumPoolSize設定為基本的無界值（如 Integer.MAX_VALUE），則允許池適應任意數量的並發任務。在大多數情況下，核心和最大池大小僅基於構造來設定，不過也可以使用 setCorePoolSize(int) 和 setMaximumPoolSize(int) 進行動態更改。

按需構造

預設情況下，即使核心線程最初只是在新任務需要時才建立和啟動的，也可以使用方法 prestartCoreThread() 或prestartAllCoreThreads() 對其進行動態重寫。
建立新線程
使用 ThreadFactory 建立新線程。如果沒有另外說明，則在同一個 ThreadGroup 中一律使用Executors.defaultThreadFactory() 建立線程，並且這些線程具有相同的 NORM_PRIORITY 優先順序和非守護進程狀態。通過提供不同的 ThreadFactory，可以改變線程的名稱、線程組、優先順序、守護進程狀態，等等。如果從 newThread 返回 null 時ThreadFactory 未能建立線程，則執行程式將繼續運行，但不能執行任何任務。

保持啟用時間

如果池中當前有多於 corePoolSize 的線程，則這些多出的線程在空閑時間超過 keepAliveTime 時將會終止（參見getKeepAliveTime(java.util.concurrent.TimeUnit)）。這提供了當池處於非使用中時減少資源消耗的方法。如果池後來變得更為活動，則可以建立新的線程。也可以使用方法 setKeepAliveTime(long, java.util.concurrent.TimeUnit) 動態地更改此參數。使用Long.MAX_VALUE TimeUnit.NANOSECONDS
的值在關閉前有效地從以前的終止狀態禁用空閑線程。

排隊

所有 BlockingQueue 都可用於傳輸和保持提交的任務。可以使用此隊列與池大小進行互動：
● 如果啟動並執行線程少於 corePoolSize，則 Executor 始終首選添加新的線程，而不進行排隊。
● 如果啟動並執行線程等於或多於 corePoolSize，則 Executor 始終首選將請求排入佇列，而不添加新的線程。
● 如果無法將請求排入佇列，則建立新的線程，除非建立此線程超出 maximumPoolSize，在這種情況下，任務將被拒絕。
排隊有三種通用策略：
1. 直接提交。工作隊列的預設選項是 SynchronousQueue，它將任務直接提交給線程而不保持它們。在此，如果不存在可用於立即運行任務的線程，則試圖把任務排入佇列將失敗，因此會構造一個新的線程。此策略可以避免在處理可能具有內部依賴性的請求集合時出現鎖定。直接提交通常要求無界 maximumPoolSizes 以避免拒絕新提交的任務。當命令以超過隊列所能處理的平均數連續到達時，此策略允許無界線程具有增長的可能性。
2. 無界隊列。使用無界隊列（例如，不具有預定義容量的 LinkedBlockingQueue）將導致在所有 corePoolSize 線程都忙的情況下將新任務排入佇列。這樣，建立的線程就不會超過 corePoolSize。（因此，maximumPoolSize 的值也就無效了。）當每個任務完全獨立於其他任務，即任務執行互不影響時，適合於使用無界隊列；例如，在 Web 頁伺服器中。這種排隊可用於處理瞬態突發請求，當命令以超過隊列所能處理的平均數連續到達時，此策略允許無界線程具有增長的可能性。
3. 有界隊列。當使用有限的 maximumPoolSizes 時，有界隊列（如 ArrayBlockingQueue）有助於防止資源耗盡，但是可能較難調整和控制。隊列大小和最大池大小可能需要相互折衷：使用大型隊列和小型池可以最大限度地降低 CPU 使用率、作業系統資源和環境切換開銷，但是可能導致人工降低輸送量。如果任務頻繁阻塞（例如，如果它們是 I/O 邊界），則系統可能為超過您許可的更多線程安排時間。使用小型隊列通常要求較大的池大小，CPU 使用率較高，但是可能遇到不可接受的調度開銷，這樣也會降低輸送量。

被拒絕的任務

當 Executor 已經關閉，並且 Executor 將有限邊界用於最大線程和工作隊列容量，且已經飽和時，在方法execute(java.lang.Runnable) 中提交的新任務將被拒絕。在以上兩種情況下，execute 方法都將調用其 RejectedExecutionHandler的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四種預定義的處理常式策略：
1. 在預設的 ThreadPoolExecutor.AbortPolicy 中，處理常式遭到拒絕將拋出運行時 RejectedExecutionException。
2. 在 ThreadPoolExecutor.CallerRunsPolicy 中，線程調用運行該任務的 execute 本身。此策略提供簡單的反饋控制機制，能夠減緩新任務的提交速度。
3. 在 ThreadPoolExecutor.DiscardPolicy 中，不能執行的任務將被刪除。
4. 在 ThreadPoolExecutor.DiscardOldestPolicy 中，如果執行程式尚未關閉，則位於工作隊列頭部的任務將被刪除，然後重試執行程式（如果再次失敗，則重複此過程）。
定義和使用其他種類的 RejectedExecutionHandler 類也是可能的，但這樣做需要非常小心，尤其是當策略僅用於特定容量或排隊策略時。

掛鈎方法

此類提供 protected 可重寫的 beforeExecute(java.lang.Thread, java.lang.Runnable) 和 afterExecute(java.lang.Runnable, java.lang.Throwable) 方法，這兩種方法分別在執行每個任務之前和之後調用。它們可用於操縱執行環境；例如，重新初始化ThreadLocal、搜集統計資訊或添加日誌條目。此外，還可以重寫方法 terminated() 來執行 Executor 完全終止後需要完成的所有特殊處理。

如果掛鈎或回調方法拋出異常，則內部輔助線程將依次失敗並突然終止。

隊列維護

方法 getQueue() 允許出於監控和調試目的而訪問工作隊列。強烈反對出於其他任何目的而使用此方法。remove(java.lang.Runnable) 和 purge() 這兩種方法可用於在取消大量已排隊任務時協助進行儲存回收。

 

執行個體：

import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.Executors; import java.util.concurrent.RejectedExecutionHandler; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledFuture; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; /** * 線程池管理 * @author LW * @date 2011-2-12 */ public class ThreadPoolManager { private static ThreadPoolManager tpm = new ThreadPoolManager(); // 線程池維護線程的最少數量 private final static int CORE_POOL_SIZE = 3; // 線程池維護線程的最大數量 private final static int MAX_POOL_SIZE = 10; // 線程池維護線程所允許的空閑時間 private final static int KEEP_ALIVE_TIME = 0; // 線程池所使用的緩衝隊列大小 private final static int WORK_QUEUE_SIZE = 10; // 任務調度周期 private final static int TASK_QOS_PERIOD = 10; // 任務緩衝隊列 private Queue<Runnable> taskQueue = new LinkedList<Runnable>(); /*   * 線程池超出界線時將任務加入緩衝隊列   */ final RejectedExecutionHandler handler = new RejectedExecutionHandler() {   public void rejectedExecution(Runnable task, ThreadPoolExecutor executor) {    taskQueue.offer(task);   } }; /*   * 將緩衝隊列中的任務重新載入到線程池   */ final Runnable accessBufferThread = new Runnable() {   public void run() {    if (hasMoreAcquire()) {     threadPool.execute(taskQueue.poll());    }   } }; /*   * 建立一個調度線程池   */ final ScheduledExecutorService scheduler = Executors    .newScheduledThreadPool(1); /*   * 通過調度線程周期性的執行緩衝隊列中任務   */ final ScheduledFuture<?> taskHandler = scheduler.scheduleAtFixedRate(    accessBufferThread, 0, TASK_QOS_PERIOD, TimeUnit.MILLISECONDS); /*   * 線程池   */ final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(    CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS,    new ArrayBlockingQueue<Runnable>(WORK_QUEUE_SIZE), this.handler); /*   * 將構造方法存取修飾詞設為私人，禁止任意執行個體化。   */ private ThreadPoolManager() { } /*   * 線程池單例建立方法   */ public static ThreadPoolManager newInstance() {   return tpm; } /*   * 訊息佇列檢查方法   */ private boolean hasMoreAcquire() {   return !taskQueue.isEmpty(); } /*   * 向線程池中新增工作方法   */ public void addExecuteTask(Runnable task) {   if (task != null) {    threadPool.execute(task);   } } }