java經常使用的幾種線程池比較

1. 爲何使用線程池

諸如 Web 服務器、數據庫服務器、文件服務器或郵件服務器之類的許多服務器應用程序都面向處理來自某些遠程來源的大量短小的任務。請求以某種方式到達服務器，這種方式多是經過網絡協議（例如 HTTP、FTP 或 POP）、經過 JMS 隊列或者可能經過輪詢數據庫。無論請求如何到達，服務器應用程序中常常出現的狀況是：單個任務處理的時間很短而請求的數目倒是巨大的。

構建服務器應用程序的一個簡單模型是：每當一個請求到達就建立一個新線程，而後在新線程中爲請求服務。實際上對於原型開發這種方法工做得很好，但若是試圖部署以這種方式運行的服務器應用程序，那麼這種方法的嚴重不足就很明顯。每一個請求對應一個線程（thread-per-request）方法的不足之一是：爲每一個請求建立一個新線程的開銷很大；爲每一個請求建立新線程的服務器在建立和銷燬線程上花費的時間和消耗的系統資源要比花在處理實際的用戶請求的時間和資源更多。

除了建立和銷燬線程的開銷以外，活動的線程也消耗系統資源。在一個 JVM 裏建立太多的線程可能會致使系統因爲過分消耗內存而用完內存或「切換過分」。爲了防止資源不足，服務器應用程序須要一些辦法來限制任何給定時刻處理的請求數目。

線程池爲線程生命週期開銷問題和資源不足問題提供瞭解決方案。經過對多個任務重用線程，線程建立的開銷被分攤到了多個任務上。其好處是，由於在請求到達時線程已經存在，因此無心中也消除了線程建立所帶來的延遲。這樣，就能夠當即爲請求服務，使應用程序響應更快。並且，經過適當地調整線程池中的線程數目，也就是當請求的數目超過某個閾值時，就強制其它任何新到的請求一直等待，直到得到一個線程來處理爲止，從而能夠防止資源不足。

2. 使用線程池的風險

雖然線程池是構建多線程應用程序的強大機制，但使用它並非沒有風險的。用線程池構建的應用程序容易遭受任何其它多線程應用程序容易遭受的全部併發風險，諸如同步錯誤和死鎖，它還容易遭受特定於線程池的少數其它風險，諸如與池有關的死鎖、資源不足和線程泄漏。

2.1 死鎖

任何多線程應用程序都有死鎖風險。當一組進程或線程中的每個都在等待一個只有該組中另外一個進程才能引發的事件時，咱們就說這組進程或線程 死鎖了。死鎖的最簡單情形是：線程 A 持有對象 X 的獨佔鎖，而且在等待對象 Y 的鎖，而線程 B 持有對象 Y 的獨佔鎖，卻在等待對象 X 的鎖。除非有某種方法來打破對鎖的等待（Java 鎖定不支持這種方法），不然死鎖的線程將永遠等下去。

雖然任何多線程程序中都有死鎖的風險，但線程池卻引入了另外一種死鎖可能，在那種狀況下，全部池線程都在執行已阻塞的等待隊列中另外一任務的執行結果的任務，但這一任務卻由於沒有未被佔用的線程而不能運行。當線程池被用來實現涉及許多交互對象的模擬，被模擬的對象能夠相互發送查詢，這些查詢接下來做爲排隊的任務執行，查詢對象又同步等待着響應時，會發生這種狀況。

2.2 資源不足

線程池的一個優勢在於：相對於其它替代調度機制（有些咱們已經討論過）而言，它們一般執行得很好。但只有恰當地調整了線程池大小時纔是這樣的。線程消耗包括內存和其它系統資源在內的大量資源。除了 Thread 對象所需的內存以外，每一個線程都須要兩個可能很大的執行調用堆棧。除此之外，JVM 可能會爲每一個 Java 線程建立一個本機線程，這些本機線程將消耗額外的系統資源。最後，雖然線程之間切換的調度開銷很小，但若是有不少線程，環境切換也可能嚴重地影響程序的性能。

若是線程池太大，那麼被那些線程消耗的資源可能嚴重地影響系統性能。在線程之間進行切換將會浪費時間，並且使用超出比您實際須要的線程可能會引發資源匱乏問題，由於池線程正在消耗一些資源，而這些資源可能會被其它任務更有效地利用。除了線程自身所使用的資源之外，服務請求時所作的工做可能須要其它資源，例如 JDBC 鏈接、套接字或文件。這些也都是有限資源，有太多的併發請求也可能引發失效，例如不能分配 JDBC 鏈接。

2.3 併發錯誤

線程池和其它排隊機制依靠使用 wait() 和 notify() 方法，這兩個方法都難於使用。若是編碼不正確，那麼可能丟失通知，致使線程保持空閒狀態，儘管隊列中有工做要處理。使用這些方法時，必須格外當心。而最好使用現有的、已經知道能工做的實現，例如 util.concurrent 包。

2.4 線程泄漏

各類類型的線程池中一個嚴重的風險是線程泄漏，當從池中除去一個線程以執行一項任務，而在任務完成後該線程卻沒有返回池時，會發生這種狀況。發生線程泄漏的一種情形出如今任務拋出一個 RuntimeException 或一個 Error 時。若是池類沒有捕捉到它們，那麼線程只會退出而線程池的大小將會永久減小一個。當這種狀況發生的次數足夠多時，線程池最終就爲空，並且系統將中止，由於沒有可用的線程來處理任務。

有些任務可能會永遠等待某些資源或來自用戶的輸入，而這些資源又不能保證變得可用，用戶可能也已經回家了，諸如此類的任務會永久中止，而這些中止的任務也會引發和線程泄漏一樣的問題。若是某個線程被這樣一個任務永久地消耗着，那麼它實際上就被從池除去了。對於這樣的任務，應該要麼只給予它們本身的線程，要麼只讓它們等待有限的時間。

2.5 請求過載

僅僅是請求就壓垮了服務器，這種狀況是可能的。在這種情形下，咱們可能不想將每一個到來的請求都排隊到咱們的工做隊列，由於排在隊列中等待執行的任務可能會消耗太多的系統資源並引發資源缺少。在這種情形下決定如何作取決於您本身；在某些狀況下，您能夠簡單地拋棄請求，依靠更高級別的協議稍後重試請求，您也能夠用一個指出服務器暫時很忙的響應來拒絕請求。

3. 有效使用線程池的準則

只要您遵循幾條簡單的準則，線程池能夠成爲構建服務器應用程序的極其有效的方法：

不要對那些同步等待其它任務結果的任務排隊。這可能會致使上面所描述的那種形式的死鎖，在那種死鎖中，全部線程都被一些任務所佔用，這些任務依次等待排隊任務的結果，而這些任務又沒法執行，由於全部的線程都很忙。

在爲時間可能很長的操做使用合用的線程時要當心。若是程序必須等待諸如 I/O 完成這樣的某個資源，那麼請指定最長的等待時間，以及隨後是失效仍是將任務從新排隊以便稍後執行。這樣作保證了：經過將某個線程釋放給某個可能成功完成的任務，從而將最終取得某些進展。

理解任務。要有效地調整線程池大小，您須要理解正在排隊的任務以及它們正在作什麼。它們是 CPU 限制的（CPU-bound）嗎？它們是 I/O 限制的（I/O-bound）嗎？您的答案將影響您如何調整應用程序。若是您有不一樣的任務類，這些類有着大相徑庭的特徵，那麼爲不一樣任務類設置多個工做隊列可能會有意義，這樣能夠相應地調整每一個池。

4. 線程池的大小設置

調整線程池的大小基本上就是避免兩類錯誤：線程太少或線程太多。幸運的是，對於大多數應用程序來講，太多和太少之間的餘地至關寬。

請回憶：在應用程序中使用線程有兩個主要優勢，儘管在等待諸如 I/O 的慢操做，但容許繼續進行處理，而且能夠利用多處理器。在運行於具備 N 個處理器機器上的計算限制的應用程序中，在線程數目接近 N 時添加額外的線程可能會改善總處理能力，而在線程數目超過 N 時添加額外的線程將不起做用。事實上，太多的線程甚至會下降性能，由於它會致使額外的環境切換開銷。

線程池的最佳大小取決於可用處理器的數目以及工做隊列中的任務的性質。若在一個具備 N 個處理器的系統上只有一個工做隊列，其中所有是計算性質的任務，在線程池具備 N 或 N+1 個線程時通常會得到最大的 CPU 利用率。

對於那些可能須要等待 I/O 完成的任務（例如，從套接字讀取 HTTP 請求的任務），須要讓池的大小超過可用處理器的數目，由於並非全部線程都一直在工做。經過使用概要分析，您能夠估計某個典型請求的等待時間（WT）與服務時間（ST）之間的比例。若是咱們將這一比例稱之爲 WT/ST，那麼對於一個具備 N 個處理器的系統，須要設置大約 N*(1+WT/ST) 個線程來保持處理器獲得充分利用。

處理器利用率不是調整線程池大小過程當中的惟一考慮事項。隨着線程池的增加，您可能會碰到調度程序、可用內存方面的限制，或者其它系統資源方面的限制，例如套接字、打開的文件句柄或數據庫鏈接等的數目。

5. 經常使用的幾種線程池

5.1 newCachedThreadPool

建立一個可緩存線程池，若是線程池長度超過處理須要，可靈活回收空閒線程，若無可回收，則新建線程。

這種類型的線程池特色是：

• 工做線程的建立數量幾乎沒有限制(其實也有限制的,數目爲Interger. MAX_VALUE), 這樣可靈活的往線程池中添加線程。
• 若是長時間沒有往線程池中提交任務，即若是工做線程空閒了指定的時間(默認爲1分鐘)，則該工做線程將自動終止。終止後，若是你又提交了新的任務，則線程池從新建立一個工做線程。
• 在使用CachedThreadPool時，必定要注意控制任務的數量，不然，因爲大量線程同時運行，頗有會形成系統癱瘓。

示例代碼以下：

 1 package test;
 2 import java.util.concurrent.ExecutorService;
 3 import java.util.concurrent.Executors;
 4 public class ThreadPoolExecutorTest {
 5  public static void main(String[] args) {
 6   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
 7   for (int i = 0; i < 10; i++) {
 8    final int index = i;
 9    try {
10     Thread.sleep(index * 1000);
11    } catch (InterruptedException e) {
12     e.printStackTrace();
13    }
14    cachedThreadPool.execute(new Runnable() {
15     public void run() {
16      System.out.println(index);
17     }
18    });
19   }
20  }
21 }

5.2 newFixedThreadPool

建立一個指定工做線程數量的線程池。每當提交一個任務就建立一個工做線程，若是工做線程數量達到線程池初始的最大數，則將提交的任務存入到池隊列中。

FixedThreadPool是一個典型且優秀的線程池，它具備線程池提升程序效率和節省建立線程時所耗的開銷的優勢。可是，在線程池空閒時，即線程池中沒有可運行任務時，它不會釋放工做線程，還會佔用必定的系統資源。

示例代碼以下：

 

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
  for (int i = 0; i < 10; i++) {
   final int index = i;
   fixedThreadPool.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}

 

由於線程池大小爲3，每一個任務輸出index後sleep 2秒，因此每兩秒打印3個數字。
定長線程池的大小最好根據系統資源進行設置如Runtime.getRuntime().availableProcessors()。

 

5.3 newSingleThreadExecutor

建立一個單線程化的Executor，即只建立惟一的工做者線程來執行任務，它只會用惟一的工做線程來執行任務，保證全部任務按照指定順序(FIFO, LIFO, 優先級)執行。若是這個線程異常結束，會有另外一個取代它，保證順序執行。單工做線程最大的特色是可保證順序地執行各個任務，而且在任意給定的時間不會有多個線程是活動的。

示例代碼以下：

 

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
  for (int i = 0; i < 10; i++) {
   final int index = i;
   singleThreadExecutor.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
} 

 

5.4 newScheduleThreadPool

建立一個定長的線程池，並且支持定時的以及週期性的任務執行，支持定時及週期性任務執行。

延遲3秒執行，延遲執行示例代碼以下：

 

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.schedule(new Runnable() {
   public void run() {
    System.out.println("delay 3 seconds");
   }
  }, 3, TimeUnit.SECONDS);
 }
}

 

表示延遲1秒後每3秒執行一次，按期執行示例代碼以下：

 

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
   public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
   }
  }, 1, 3, TimeUnit.SECONDS);
 }
}