併發編程系列-線程池的正確使用

在Java語言中，創建線程並不像創建對象一樣簡單。雖然只需要使用new Thread()即可創建線程，但實際上創建線程比創建對象複雜得多。創建對象只需在JVM的堆中分配記憶體，而創建線程需要調用操作系統內核的API，併為線程分配一系列資源，這個成本相對較高。因此，線程被視為重量級的對象，應儘量避免頻繁... ...

在Java語言中，創建線程並不像創建對象一樣簡單。雖然只需要使用new Thread()即可創建線程，但實際上創建線程比創建對象複雜得多。創建對象只需在JVM的堆中分配記憶體，而創建線程需要調用操作系統內核的API，併為線程分配一系列資源，這個成本相對較高。因此，線程被視為重量級的對象，應儘量避免頻繁創建和銷毀。

那麼如何避免頻繁創建線程呢？解決方案就是使用線程池。

由於線程池的需求非常普遍，所以Java SDK的併發包自然也包含了線程池。但是，很多人初次接觸併發包中與線程池相關的工具類時，可能會感到有些困惑，不知從何入手。我認為，這主要是因為線程池與通常意義上的資源池是不同的。一般意義上的資源池在需要資源時調用acquire()方法申請資源，在使用完畢後調用release()釋放資源。然而，如果你帶著這種固有模型來看待併發包中的線程池相關工具類，會遺憾地發現它們與之不匹配，因為Java提供的線程池中根本不存在申請線程和釋放線程的方法。

class XXXPool{
  // 獲取池化資源
  XXX acquire() {
  }
  // 釋放池化資源
  void release(XXX x){
  }
}

線程池是一種生產者-消費者模式

線程池之所以沒有採用一般意義上池化資源的設計方法，是因為線程池是基於生產者-消費者模式的設計。

在一般意義上的池化資源設計中，我們可以通過acquire()方法獲取到一個空閑資源，然後通過使用資源來執行具體的任務，最後再通過release()方法釋放資源。但是線上程池中，由於涉及到線程的管理和復用，採用了不同的設計思路。

當我們從線程池中獲取到一個空閑線程時，我們期望能夠像使用Thread類創建線程那樣，通過調用該線程的execute()方法，傳入一個Runnable對象來執行具體的業務邏輯。然而，遺憾的是，Thread類並沒有像execute(Runnable target)這樣的公共方法。這是因為線程池在管理線程時，需要考慮到線程的狀態、任務隊列等方面的複雜情況，因此不能簡單地將線程的使用方式與傳統的池化資源相同。

//採用一般意義上池化資源的設計方法
class ThreadPool{
  // 獲取空閑線程
  Thread acquire() {
  }
  // 釋放線程
  void release(Thread t){
  }
}
//期望的使用
ThreadPool pool；
Thread T1=pool.acquire();
//傳入Runnable對象
T1.execute(()->{
  //具體業務邏輯
  ......
});

所以，線程池的設計，沒有辦法直接採用一般意義上池化資源的設計方法。那線程池該如何設計呢？目前業界線程池的設計，普遍採用的都是 生產者-消費者模式。線程池的使用方是生產者，線程池本身是消費者。在下麵的示例代碼中，我們創建了一個非常簡單的線程池MyThreadPool，你可以通過它來理解線程池的工作原理。

//簡化的線程池，僅用來說明工作原理
class MyThreadPool{
  //利用阻塞隊列實現生產者-消費者模式
  BlockingQueue<Runnable> workQueue;
  //保存內部工作線程
  List<WorkerThread> threads
    = new ArrayList<>();
  // 構造方法
  MyThreadPool(int poolSize,
    BlockingQueue<Runnable> workQueue){
    this.workQueue = workQueue;
    // 創建工作線程
    for(int idx=0; idx<poolSize; idx++){
      WorkerThread work = new WorkerThread();
      work.start();
      threads.add(work);
    }
  }
  // 提交任務
  void execute(Runnable command){
    workQueue.put(command);
  }
  // 工作線程負責消費任務，並執行任務
  class WorkerThread extends Thread{
    public void run() {
      //迴圈取任務並執行
      while(true){ ①
        Runnable task = workQueue.take();
        task.run();
      }
    }
  }
}

/** 下麵是使用示例 **/
// 創建有界阻塞隊列
BlockingQueue<Runnable> workQueue =
  new LinkedBlockingQueue<>(2);
// 創建線程池
MyThreadPool pool = new MyThreadPool(
  10, workQueue);
// 提交任務
pool.execute(()->{
    System.out.println("hello");
});

在MyThreadPool的內部，我們維護了一個阻塞隊列workQueue和一組工作線程，工作線程的個數由構造函數中的poolSize來指定。用戶通過調用execute()方法來提交Runnable任務，execute()方法的內部實現僅僅是將任務加入到workQueue中。MyThreadPool內部維護的工作線程會消費workQueue中的任務並執行任務，相關的代碼就是代碼①處的while迴圈。線程池主要的工作原理就這些，是不是還挺簡單的？

如何使用Java中的線程池

Java併發包里提供的線程池，遠比我們上面的示例代碼強大得多，當然也複雜得多。Java提供的線程池相關的工具類中，最核心的是 ThreadPoolExecutor，通過名字你也能看出來，它強調的是Executor，而不是一般意義上的池化資源。

ThreadPoolExecutor的構造函數非常複雜，如下麵代碼所示，這個最完備的構造函數有7個參數。

ThreadPoolExecutor(
  int corePoolSize,
  int maximumPoolSize,
  long keepAliveTime,
  TimeUnit unit,
  BlockingQueue<Runnable> workQueue,
  ThreadFactory threadFactory,
  RejectedExecutionHandler handler)

下麵我們逐一介紹這些參數的含義，將線程池類比為一個項目組，而每個線程就是項目組的成員。

corePoolSize：表示線程池所持有的最小線程數。有些項目可能很閑，但也不能將所有項目組成員都撤離，至少要留下corePoolSize個人守在崗位上。
maximumPoolSize：表示線程池可創建的最大線程數。當項目繁忙時，需要增加成員，但也不能無限制地增加，最多增加到maximumPoolSize個人。當項目變得閑暇時，需要減少成員，最多將成員減至corePoolSize個人。
keepAliveTime & unit：前面提到，項目根據忙閑來增減成員。在編程世界中，如何定義忙和閑呢？很簡單，如果一個線程在一段時間內都沒有執行任務，說明它處於閑置狀態。而keepAliveTime和unit就用來定義這段時間的參數。也就是說，如果一個線程空閑了keepAliveTime & unit這麼長時間，並且線程池的線程數超過了corePoolSize，那麼該空閑線程就會被回收。
workQueue：工作隊列，與上面示例代碼中的工作隊列意義相同。
threadFactory：通過該參數，你可以自定義如何創建線程。例如，你可以為線程指定一個有意義的名稱。
handler：通過該參數，你可以自定義任務的拒絕策略。如果線程池中所有的線程都在忙碌，且工作隊列已滿（前提是工作隊列是有界隊列），此時提交任務，線程池將會拒絕接收。至於拒絕策略，你可以通過handler參數來指定。ThreadPoolExecutor已經提供了以下四種策略：

CallerRunsPolicy：提交任務的線程自行執行該任務。
AbortPolicy：預設的拒絕策略，會拋出RejectedExecutionException異常。
DiscardPolicy：直接丟棄任務，沒有任何異常拋出。
DiscardOldestPolicy：丟棄最老的任務，實際上是丟棄最早進入工作隊列的任務，並將新任務加入工作隊列。

Java 1.6版本還增加了allowCoreThreadTimeOut(boolean value)方法，它可以使所有線程都支持超時。這意味著如果項目很閑，項目組的成員都會被撤離。

使用線程池要註意些什麼

考慮到ThreadPoolExecutor的構造函數相對複雜，Java併發包提供了一個線程池的靜態工廠類Executors，通過Executors可以快速創建線程池。不過，目前大型公司的編碼規範一般不建議使用Executors，所以我就不再詳細介紹這方面內容了。

不建議使用Executors最重要的原因是：Executors提供的許多方法預設使用無界的LinkedBlockingQueue。在高負載情況下，無界隊列很容易導致OOM（記憶體溢出），而OOM會導致所有請求都無法處理，這是一個嚴重的問題。因此，強烈建議使用有界隊列。

使用有界隊列時，當任務過多時，線程池會觸發執行拒絕策略。線程池的預設拒絕策略會拋出RejectedExecutionException異常，這是一個運行時異常，編譯器不會強制要求捕獲它，因此開發人員很容易忽略。因此，在使用預設拒絕策略時要謹慎。如果線程池處理的任務非常重要，建議自定義拒絕策略，併在實際工作中將自定義的拒絕策略與降級策略配合使用。

在使用線程池時，還需要註意異常處理的問題。例如，通過ThreadPoolExecutor對象的execute()方法提交任務時，如果任務在執行過程中出現運行時異常，會導致執行該任務的線程終止。然而，最致命的是儘管任務發生異常，你卻無法獲得任何通知，這可能讓你誤以為任務都正常執行了。儘管線程池提供了許多用於異常處理的方法，但最可靠和簡單的方案是捕獲所有異常並根據需要進行處理，你可以參考下麵的示例代碼。

try {
  //業務邏輯
} catch (RuntimeException x) {
  //按需處理
} catch (Throwable x) {
  //按需處理
}

總結

線程池在Java併發編程領域中扮演著重要角色，許多大型公司的編碼規範要求使用線程池來管理線程。線程池與普通的資源池有很大的區別，實際上它是生產者-消費者模式的一種實現。理解生產者-消費者模式是理解線程池的關鍵所在。

本文來自博客園，作者：古道輕風，轉載請註明原文鏈接：https://www.cnblogs.com/88223100/p/Concurrent-Programming-Series---Thread-Pools.html