本文轉自：https://www.javadoop.com/

本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視
> https://github.com/h2pl/Java-Tutorial

喜歡的話麻煩點下Star哈

文章同步發於我的個人部落格：
> www.how2playlife.com

本文是微信公眾號【Java技術江湖】的《Java併發指南》其中一篇，本文大部分內容來源於網路，為了把本文主題講得清晰透徹，也整合了很多我認為不錯的技術部落格內容，引用其中了一些比較好的部落格文章，如有侵權，請聯絡作者。

該系列博文會告訴你如何全面深入地學習Java併發技術，從Java多執行緒基礎，再到併發程式設計的基礎知識，從Java併發包的入門和實戰，再到JUC的原始碼剖析，一步步地學習Java併發程式設計，並上手進行實戰，以便讓你更完整地瞭解整個Java併發程式設計知識體系，形成自己的知識框架。

為了更好地總結和檢驗你的學習成果，本系列文章也會提供一些對應的面試題以及參考答案。

如果對本系列文章有什麼建議，或者是有什麼疑問的話，也可以關注公眾號【Java技術江湖】聯絡作者，歡迎你參與本系列博文的創作和修訂。

## 前言

我相信大家都看過很多的關於執行緒池的文章，基本上也是面試的時候必問的，如果你在看過很多文章以後，還是一知半解的，那希望這篇文章能讓你真正的掌握好 Java 執行緒池。

本文一大重點是原始碼解析，同時會有少量篇幅介紹執行緒池設計思想以及作者 Doug Lea 實現過程中的一些巧妙用法。本文還是會一行行關鍵程式碼進行分析，目的是為了讓那些自己看原始碼不是很理解的同學可以得到參考。

執行緒池是非常重要的工具，如果你要成為一個好的工程師，還是得比較好地掌握這個知識，很多線上問題都是因為沒有用好執行緒池導致的。即使你為了謀生，也要知道，這基本上是面試必問的題目，而且面試官很容易從被面試者的回答中捕捉到被面試者的技術水平。

本文略長，建議在 pc 上閱讀，邊看文章邊翻原始碼（Java7 和 Java8 都一樣），建議想好好看的讀者抽出至少 30 分鐘的整塊時間來閱讀。當然，如果讀者僅為面試準備，可以直接滑到最後的**總結**部分。

## 總覽

開篇來一些廢話。下圖是 java 執行緒池幾個相關類的繼承結構：

![1](https://www.javadoop.com/blogimages/java-thread-pool/1.jpg)

先簡單說說這個繼承結構，Executor 位於最頂層，也是最簡單的，就一個 execute(Runnable runnable) 介面方法定義。

ExecutorService 也是介面，在 Executor 介面的基礎上新增了很多的介面方法，所以**一般來說我們會使用這個介面**。

然後再下來一層是 AbstractExecutorService，從名字我們就知道，這是抽象類，這裡實現了非常有用的一些方法供子類直接使用，之後我們再細說。

然後才到我們的重點部分 ThreadPoolExecutor 類，這個類提供了關於執行緒池所需的非常豐富的功能。

另外，我們還涉及到下圖中的這些類：

![others](https://www.javadoop.com/blogimages/java-thread-pool/others.png)

同在併發包中的 Executors 類，類名中帶字母 s，我們猜到這個是工具類，裡面的方法都是靜態方法，如以下我們最常用的用於生成 ThreadPoolExecutor 的例項的一些方法：

```
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<runnable>());
}
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<runnable>());
}
```

另外，由於執行緒池支援**獲取執行緒執行的結果**，所以，引入了 Future 介面，RunnableFuture 繼承自此介面，然後我們最需要關心的就是它的實現類 FutureTask。到這裡，記住這個概念，線上程池的使用過程中，我們是往執行緒池提交任務（task），使用過執行緒池的都知道，我們提交的每個任務是實現了 Runnable 介面的，其實就是先將 Runnable 的任務包裝成 FutureTask，然後再提交到執行緒池。這樣，讀者才能比較容易記住 FutureTask 這個類名：它首先是一個任務（Task），然後具有 Future 介面的語義，即可以在將來（Future）得到執行的結果。

當然，執行緒池中的 BlockingQueue 也是非常重要的概念，如果執行緒數達到 corePoolSize，我們的每個任務會提交到等待佇列中，等待執行緒池中的執行緒來取任務並執行。這裡的 BlockingQueue 通常我們使用其實現類 LinkedBlockingQueue、ArrayBlockingQueue 和 SynchronousQueue，每個實現類都有不同的特徵，使用場景之後會慢慢分析。想要詳細瞭解各個 BlockingQueue 的讀者，可以參考我的前面的一篇對 BlockingQueue 的各個實現類進行詳細分析的文章。

> 把事情說完整：除了上面說的這些類外，還有一個很重要的類，就是定時任務實現類 ScheduledThreadPoolExecutor，它繼承自本文要重點講解的 ThreadPoolExecutor，用於實現定時執行。不過本文不會介紹它的實現，我相信讀者看完本文後可以比較容易地看懂它的原始碼。

以上就是本文要介紹的知識，廢話不多說，開始進入正文。

## Executor 介面

```
/* 
 * @since 1.5
 * @author Doug Lea
 */
public interface Executor {
    void execute(Runnable command);
}
```

我們可以看到 Executor 介面非常簡單，就一個 `void execute(Runnable command)` 方法，代表提交一個任務。為了讓大家理解 java 執行緒池的整個設計方案，我會按照 Doug Lea 的設計思路來多說一些相關的東西。

我們經常這樣啟動一個執行緒：

```
new Thread(new Runnable(){
  // do something
}).start();
```

用了執行緒池 Executor 後就可以像下面這麼使用：

```
Executor executor = anExecutor;
executor.execute(new RunnableTask1());
executor.execute(new RunnableTask2());
```

如果我們希望執行緒池同步執行每一個任務，我們可以這麼實現這個介面：

```
class DirectExecutor implements Executor {
    public void execute(Runnable r) {
        r.run();// 這裡不是用的new Thread(r).start()，也就是說沒有啟動任何一個新的執行緒。
    }
}
```

我們希望每個任務提交進來後，直接啟動一個新的執行緒來執行這個任務，我們可以這麼實現：

```
class ThreadPerTaskExecutor implements Executor {
    public void execute(Runnable r) {
        new Thread(r).start();  // 每個任務都用一個新的執行緒來執行
    }
}
```

我們再來看下怎麼組合兩個 Executor 來使用，下面這個實現是將所有的任務都加到一個 queue 中，然後從 queue 中取任務，交給真正的執行器執行，這裡採用 synchronized 進行併發控制：

```
class SerialExecutor implements Executor {
    // 任務佇列
    final Queue<runnable> tasks = new ArrayDeque<runnable>();
    // 這個才是真正的執行器
    final Executor executor;
    // 當前正在執行的任務
    Runnable active;

// 初始化的時候，指定執行器
    SerialExecutor(Executor executor) {
        this.executor = executor;
    }

// 新增任務到執行緒池: 將任務新增到任務佇列，scheduleNext 觸發執行器去任務佇列取任務
    public synchronized void execute(final Runnable r) {
        tasks.offer(new Runnable() {
            public void run() {
                try {
                    r.run();
                } finally {
                    scheduleNext();
                }
            }
        });
        if (active == null) {
            scheduleNext();
        }
    }

protected synchronized void scheduleNext() {
        if ((active = tasks.poll()) != null) {
            // 具體的執行轉給真正的執行器 executor
            executor.execute(active);
        }
    }
}
```

當然了，Executor 這個介面只有提交任務的功能，太簡單了，我們想要更豐富的功能，比如我們想知道執行結果、我們想知道當前執行緒池有多少個執行緒活著、已經完成了多少任務等等，這些都是這個介面的不足的地方。接下來我們要介紹的是繼承自 `Executor` 介面的 `ExecutorService` 介面，這個介面提供了比較豐富的功能，也是我們最常使用到的介面。

## ExecutorService

一般我們定義一個執行緒池的時候，往往都是使用這個介面：

```
ExecutorService executor = Executors.newFixedThreadPool(args...);
ExecutorService executor = Executors.newCachedThreadPool(args...);
```

因為這個介面中定義的一系列方法大部分情況下已經可以滿足我們的需要了。

那麼我們簡單初略地來看一下這個介面中都有哪些方法：

```
public interface ExecutorService extends Executor {

// 關閉執行緒池，已提交的任務繼續執行，不接受繼續提交新任務
    void shutdown();

// 關閉執行緒池，嘗試停止正在執行的所有任務，不接受繼續提交新任務
    // 它和前面的方法相比，加了一個單詞“now”，區別在於它會去停止當前正在進行的任務
    List<runnable> shutdownNow();

// 執行緒池是否已關閉
    boolean isShutdown();

// 如果呼叫了 shutdown() 或 shutdownNow() 方法後，所有任務結束了，那麼返回true
    // 這個方法必須在呼叫shutdown或shutdownNow方法之後呼叫才會返回true
    boolean isTerminated();

// 等待所有任務完成，並設定超時時間
    // 我們這麼理解，實際應用中是，先呼叫 shutdown 或 shutdownNow，
    // 然後再調這個方法等待所有的執行緒真正地完成，返回值意味著有沒有超時
    boolean awaitTermination(long timeout, TimeUnit unit)
            throws InterruptedException;

// 提交一個 Callable 任務
    <t> Future<t> submit(Callable<t> task);

// 提交一個 Runnable 任務，第二個引數將會放到 Future 中，作為返回值，
    // 因為 Runnable 的 run 方法本身並不返回任何東西
    <t> Future<t> submit(Runnable task, T result);

// 提交一個 Runnable 任務
    Future> submit(Runnable task);

// 執行所有任務，返回 Future 型別的一個 list
    <t> List<future>> invokeAll(Collection extends Callable<t>> tasks)
            throws InterruptedException;

// 也是執行所有任務，但是這裡設定了超時時間
    <t> List<future>> invokeAll(Collection extends Callable<t>> tasks,
                                  long timeout, TimeUnit unit)
            throws InterruptedException;

// 只有其中的一個任務結束了，就可以返回，返回執行完的那個任務的結果
    <t> T invokeAny(Collection extends Callable<t>> tasks)
            throws InterruptedException, ExecutionException;

// 同上一個方法，只有其中的一個任務結束了，就可以返回，返回執行完的那個任務的結果，
    // 不過這個帶超時，超過指定的時間，丟擲 TimeoutException 異常
    <t> T invokeAny(Collection extends Callable<t>> tasks,
                    long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
}
```

這些方法都很好理解，一個簡單的執行緒池主要就是這些功能，能提交任務，能獲取結果，能關閉執行緒池，這也是為什麼我們經常用這個介面的原因。

## FutureTask

在繼續往下層介紹 ExecutorService 的實現類之前，我們先來說說相關的類 FutureTask。

```
Future      Runnable
   \           /
    \         /
   RunnableFuture
          |
          |
      FutureTask

FutureTask 透過 RunnableFuture 間接實現了 Runnable 介面，
所以每個 Runnable 通常都先包裝成 FutureTask，
然後呼叫 executor.execute(Runnable command) 將其提交給執行緒池
```

我們知道，Runnable 的 void run() 方法是沒有返回值的，所以，通常，如果我們需要的話，會在 submit 中指定第二個引數作為返回值：

```
<t> Future<t> submit(Runnable task, T result);
```

其實到時候會透過這兩個引數，將其包裝成 Callable。它和 Runnable 的區別在於 run() 沒有返回值，而 Callable 的 call() 方法有返回值，同時，如果執行出現異常，call() 方法會丟擲異常。

```
public interface Callable<v> {

V call() throws Exception;
}
```

在這裡，就不展開說 FutureTask 類了，因為本文篇幅本來就夠大了，這裡我們需要知道怎麼用就行了。

下面，我們來看看 `ExecutorService` 的抽象實現 `AbstractExecutorService` 。

## AbstractExecutorService

AbstractExecutorService 抽象類派生自 ExecutorService 介面，然後在其基礎上實現了幾個實用的方法，這些方法提供給子類進行呼叫。

這個抽象類實現了 invokeAny 方法和 invokeAll 方法，這裡的兩個 newTaskFor 方法也比較有用，用於將任務包裝成 FutureTask。定義於最上層介面 Executor中的 `void execute(Runnable command)` 由於不需要獲取結果，不會進行 FutureTask 的包裝。

> 需要獲取結果（FutureTask），用 submit 方法，不需要獲取結果，可以用 execute 方法。

下面，我將一行一行原始碼地來分析這個類，跟著原始碼來看看其實現吧：

> Tips: invokeAny 和 invokeAll 方法佔了這整個類的絕大多數篇幅，讀者可以選擇適當跳過，因為它們可能在你的實踐中使用的頻次比較低，而且它們不帶有承前啟後的作用，不用擔心會漏掉什麼導致看不懂後面的程式碼。

```
public abstract class AbstractExecutorService implements ExecutorService {

// RunnableFuture 是用於獲取執行結果的，我們常用它的子類 FutureTask
    // 下面兩個 newTaskFor 方法用於將我們的任務包裝成 FutureTask 提交到執行緒池中執行
    protected <t> RunnableFuture<t> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<t>(runnable, value);
    }

protected <t> RunnableFuture<t> newTaskFor(Callable<t> callable) {
        return new FutureTask<t>(callable);
    }

// 提交任務
    public Future> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        // 1\. 將任務包裝成 FutureTask
        RunnableFuture<void> ftask = newTaskFor(task, null);
        // 2\. 交給執行器執行，execute 方法由具體的子類來實現
        // 前面也說了，FutureTask 間接實現了Runnable 介面。
        execute(ftask);
        return ftask;
    }

public <t> Future<t> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        // 1\. 將任務包裝成 FutureTask
        RunnableFuture<t> ftask = newTaskFor(task, result);
        // 2\. 交給執行器執行
        execute(ftask);
        return ftask;
    }

public <t> Future<t> submit(Callable<t> task) {
        if (task == null) throw new NullPointerException();
        // 1\. 將任務包裝成 FutureTask
        RunnableFuture<t> ftask = newTaskFor(task);
        // 2\. 交給執行器執行
        execute(ftask);
        return ftask;
    }

// 此方法目的：將 tasks 集合中的任務提交到執行緒池執行，任意一個執行緒執行完後就可以結束了
    // 第二個引數 timed 代表是否設定超時機制，超時時間為第三個引數，
    // 如果 timed 為 true，同時超時了還沒有一個執行緒返回結果，那麼丟擲 TimeoutException 異常
    private <t> T doInvokeAny(Collection extends Callable<t>> tasks,
                            boolean timed, long nanos)
        throws InterruptedException, ExecutionException, TimeoutException {
        if (tasks == null)
            throw new NullPointerException();
        // 任務數
        int ntasks = tasks.size();
        if (ntasks == 0)
            throw new IllegalArgumentException();
        // 
        List<future>> futures= new ArrayList<future>>(ntasks);

// ExecutorCompletionService 不是一個真正的執行器，引數 this 才是真正的執行器
        // 它對執行器進行了包裝，每個任務結束後，將結果儲存到內部的一個 completionQueue 佇列中
        // 這也是為什麼這個類的名字裡面有個 Completion 的原因吧。
        ExecutorCompletionService<t> ecs =
            new ExecutorCompletionService<t>(this);
        try {
            // 用於儲存異常資訊，此方法如果沒有得到任何有效的結果，那麼我們可以丟擲最後得到的一個異常
            ExecutionException ee = null;
            long lastTime = timed ? System.nanoTime() : 0;
            Iterator extends Callable<t>> it = tasks.iterator();

// 首先先提交一個任務，後面的任務到下面的 for 迴圈一個個提交
            futures.add(ecs.submit(it.next()));
            // 提交了一個任務，所以任務數量減 1
            --ntasks;
            // 正在執行的任務數(提交的時候 +1，任務結束的時候 -1)
            int active = 1;

for (;;) {
                // ecs 上面說了，其內部有一個 completionQueue 用於儲存執行完成的結果
                // BlockingQueue 的 poll 方法不阻塞，返回 null 代表佇列為空
                Future<t> f = ecs.poll();
                // 為 null，說明剛剛提交的第一個執行緒還沒有執行完成
                // 在前面先提交一個任務，加上這裡做一次檢查，也是為了提高效能
                if (f == null) {
                    if (ntasks > 0) {
                        --ntasks;
                        futures.add(ecs.submit(it.next()));
                        ++active;
                    }
                    // 這裡是 else if，不是 if。這裡說明，沒有任務了，同時 active 為 0 說明
                    // 任務都執行完成了。其實我也沒理解為什麼這裡做一次 break？
                    // 因為我認為 active 為 0 的情況，必然從下面的 f.get() 返回了

// 2018-02-23 感謝讀者 newmicro 的 comment，
                    //  這裡的 active == 0，說明所有的任務都執行失敗，那麼這裡是 for 迴圈出口
                    else if (active == 0)
                        break;
                    // 這裡也是 else if。這裡說的是，沒有任務了，但是設定了超時時間，這裡檢測是否超時
                    else if (timed) {
                        // 帶等待的 poll 方法
                        f = ecs.poll(nanos, TimeUnit.NANOSECONDS);
                        // 如果已經超時，丟擲 TimeoutException 異常，這整個方法就結束了
                        if (f == null)
                            throw new TimeoutException();
                        long now = System.nanoTime();
                        nanos -= now - lastTime;
                        lastTime = now;
                    }
                    // 這裡是 else。說明，沒有任務需要提交，但是池中的任務沒有完成，還沒有超時(如果設定了超時)
                    // take() 方法會阻塞，直到有元素返回，說明有任務結束了
                    else
                        f = ecs.take();
                }
                /*
                 * 我感覺上面這一段並不是很好理解，這裡簡單說下。
                 * 1\. 首先，這在一個 for 迴圈中，我們設想每一個任務都沒那麼快結束，
                 *     那麼，每一次都會進到第一個分支，進行提交任務，直到將所有的任務都提交了
                 * 2\. 任務都提交完成後，如果設定了超時，那麼 for 迴圈其實進入了“一直檢測是否超時”
                       這件事情上
                 * 3\. 如果沒有設定超時機制，那麼不必要檢測超時，那就會阻塞在 ecs.take() 方法上，
                       等待獲取第一個執行結果
                 * 4\. 如果所有的任務都執行失敗，也就是說 future 都返回了，
                       但是 f.get() 丟擲異常，那麼從 active == 0 分支出去(感謝 newmicro 提出)
                         // 當然，這個需要看下面的 if 分支。
                 */

// 有任務結束了
                if (f != null) {
                    --active;
                    try {
                        // 返回執行結果，如果有異常，都包裝成 ExecutionException
                        return f.get();
                    } catch (ExecutionException eex) {
                        ee = eex;
                    } catch (RuntimeException rex) {
                        ee = new ExecutionException(rex);
                    }
                }
            }// 注意看 for 迴圈的範圍，一直到這裡

if (ee == null)
                ee = new ExecutionException();
            throw ee;

} finally {
            // 方法退出之前，取消其他的任務
            for (Future<t> f : futures)
                f.cancel(true);
        }
    }

public <t> T invokeAny(Collection extends Callable<t>> tasks)
        throws InterruptedException, ExecutionException {
        try {
            return doInvokeAny(tasks, false, 0);
        } catch (TimeoutException cannotHappen) {
            assert false;
            return null;
        }
    }

public <t> T invokeAny(Collection extends Callable<t>> tasks,
                           long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
        return doInvokeAny(tasks, true, unit.toNanos(timeout));
    }

// 執行所有的任務，返回任務結果。
    // 先不要看這個方法，我們先想想，其實我們自己提交任務到執行緒池，也是想要執行緒池執行所有的任務
    // 只不過，我們是每次 submit 一個任務，這裡以一個集合作為引數提交
    public <t> List<future>> invokeAll(Collection extends Callable<t>> tasks)
        throws InterruptedException {
        if (tasks == null)
            throw new NullPointerException();
        List<future>> futures = new ArrayList<future>>(tasks.size());
        boolean done = false;
        try {
            // 這個很簡單
            for (Callable<t> t : tasks) {
                // 包裝成 FutureTask
                RunnableFuture<t> f = newTaskFor(t);
                futures.add(f);
                // 提交任務
                execute(f);
            }
            for (Future<t> f : futures) {
                if (!f.isDone()) {
                    try {
                        // 這是一個阻塞方法，直到獲取到值，或丟擲了異常
                        // 這裡有個小細節，其實 get 方法簽名上是會丟擲 InterruptedException 的
                        // 可是這裡沒有進行處理，而是拋給外層去了。此異常發生於還沒執行完的任務被取消了
                        f.get();
                    } catch (CancellationException ignore) {
                    } catch (ExecutionException ignore) {
                    }
                }
            }
            done = true;
            // 這個方法返回，不像其他的場景，返回 List<future>，其實執行結果還沒出來
            // 這個方法返回是真正的返回，任務都結束了
            return futures;
        } finally {
            // 為什麼要這個？就是上面說的有異常的情況
            if (!done)
                for (Future<t> f : futures)
                    f.cancel(true);
        }
    }

// 帶超時的 invokeAll，我們找不同吧
    public <t> List<future>> invokeAll(Collection extends Callable<t>> tasks,
                                         long timeout, TimeUnit unit)
        throws InterruptedException {
        if (tasks == null || unit == null)
            throw new NullPointerException();
        long nanos = unit.toNanos(timeout);
        List<future>> futures = new ArrayList<future>>(tasks.size());
        boolean done = false;
        try {
            for (Callable<t> t : tasks)
                futures.add(newTaskFor(t));

long lastTime = System.nanoTime();

Iterator<future>> it = futures.iterator();
            // 每提交一個任務，檢測一次是否超時
            while (it.hasNext()) {
                execute((Runnable)(it.next()));
                long now = System.nanoTime();
                nanos -= now - lastTime;
                lastTime = now;
                // 超時
                if (nanos <= 0)
                    return futures;
            }

for (Future<t> f : futures) {
                if (!f.isDone()) {
                    if (nanos <= 0)
                        return futures;
                    try {
                        // 呼叫帶超時的 get 方法，這裡的引數 nanos 是剩餘的時間，
                        // 因為上面其實已經用掉了一些時間了
                        f.get(nanos, TimeUnit.NANOSECONDS);
                    } catch (CancellationException ignore) {
                    } catch (ExecutionException ignore) {
                    } catch (TimeoutException toe) {
                        return futures;
                    }
                    long now = System.nanoTime();
                    nanos -= now - lastTime;
                    lastTime = now;
                }
            }
            done = true;
            return futures;
        } finally {
            if (!done)
                for (Future<t> f : futures)
                    f.cancel(true);
        }
    }

}
```

到這裡，我們發現，這個抽象類包裝了一些基本的方法，可是像 submit、invokeAny、invokeAll 等方法，它們都沒有真正開啟執行緒來執行任務，它們都只是在方法內部呼叫了 execute 方法，所以最重要的 execute(Runnable runnable) 方法還沒出現，需要等具體執行器來實現這個最重要的部分，這裡我們要說的就是 ThreadPoolExecutor 類了。

> 鑑於本文的篇幅，我覺得看到這裡的讀者應該已經不多了，大家都習慣了快餐文化。我寫的每篇文章都力求讓讀者可以透過我的一篇文章而對相關內容有全面的瞭解，所以篇幅不免長了些。

## ThreadPoolExecutor

ThreadPoolExecutor 是 JDK 中的執行緒池實現，這個類實現了一個執行緒池需要的各個方法，它實現了任務提交、執行緒管理、監控等等方法。

我們可以基於它來進行業務上的擴充套件，以實現我們需要的其他功能，比如實現定時任務的類 ScheduledThreadPoolExecutor 就繼承自 ThreadPoolExecutor。當然，這不是本文關注的重點，下面，還是趕緊進行原始碼分析吧。

首先，我們來看看執行緒池實現中的幾個概念和處理流程。

我們先回顧下提交任務的幾個方法：

```
public Future> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<void> ftask = newTaskFor(task, null);
    execute(ftask);
    return ftask;
}
public <t> Future<t> submit(Runnable task, T result) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<t> ftask = newTaskFor(task, result);
    execute(ftask);
    return ftask;
}
public <t> Future<t> submit(Callable<t> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<t> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}
```

一個最基本的概念是，submit 方法中，引數是 Runnable 型別（也有Callable 型別），這個引數不是用於 new Thread(**runnable**).start() 中的，此處的這個引數不是用於啟動執行緒的，這裡指的是**任務**，任務要做的事情是 run() 方法裡面定義的或 Callable 中的 call() 方法裡面定義的。

初學者往往會搞混這個，因為 Runnable 總是在各個地方出現，經常把一個 Runnable 包到另一個 Runnable 中。請把它想象成有個 Task 介面，這個介面裡面有一個 run() 方法。

我們回過神來繼續往下看，我畫了一個簡單的示意圖來描述執行緒池中的一些主要的構件：

![pool-1](https://www.javadoop.com/blogimages/java-thread-pool/pool-1.png)

當然，上圖沒有考慮佇列是否有界，提交任務時佇列滿了怎麼辦？什麼情況下會建立新的執行緒？提交任務時執行緒池滿了怎麼辦？空閒執行緒怎麼關掉？這些問題下面我們會一一解決。

我們經常會使用 `Executors` 這個工具類來快速構造一個執行緒池，對於初學者而言，這種工具類是很有用的，開發者不需要關注太多的細節，只要知道自己需要一個執行緒池，僅僅提供必需的引數就可以了，其他引數都採用作者提供的預設值。

```
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<runnable>());
}
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<runnable>());
}
```

這裡先不說有什麼區別，它們最終都會導向這個構造方法：

```
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        // 這幾個引數都是必須要有的
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();

this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }
```

基本上，上面的構造方法中列出了我們最需要關心的幾個屬性了，下面逐個介紹下構造方法中出現的這幾個屬性：

*   corePoolSize

> 核心執行緒數，不要摳字眼，反正先記著有這麼個屬性就可以了。

*   maximumPoolSize

> 最大執行緒數，執行緒池允許建立的最大執行緒數。

*   workQueue

> 任務佇列，BlockingQueue 介面的某個實現（常使用 ArrayBlockingQueue 和 LinkedBlockingQueue）。

*   keepAliveTime

> 空閒執行緒的保活時間，如果某執行緒的空閒時間超過這個值都沒有任務給它做，那麼可以被關閉了。注意這個值並不會對所有執行緒起作用，如果執行緒池中的執行緒數少於等於核心執行緒數 corePoolSize，那麼這些執行緒不會因為空閒太長時間而被關閉，當然，也可以透過呼叫 `allowCoreThreadTimeOut(true)`使核心執行緒數內的執行緒也可以被回收。

*   threadFactory

> 用於生成執行緒，一般我們可以用預設的就可以了。通常，我們可以透過它將我們的執行緒的名字設定得比較可讀一些，如 Message-Thread-1， Message-Thread-2 類似這樣。

*   handler：

> 當執行緒池已經滿了，但是又有新的任務提交的時候，該採取什麼策略由這個來指定。有幾種方式可供選擇，像丟擲異常、直接拒絕然後返回等，也可以自己實現相應的介面實現自己的邏輯，這個之後再說。

除了上面幾個屬性外，我們再看看其他重要的屬性。

Doug Lea 採用一個 32 位的整數來存放執行緒池的狀態和當前池中的執行緒數，其中高 3 位用於存放執行緒池狀態，低 29 位表示執行緒數（即使只有 29 位，也已經不小了，大概 5 億多，現在還沒有哪個機器能起這麼多執行緒的吧）。我們知道，java 語言在整數編碼上是統一的，都是採用補碼的形式，下面是簡單的移位操作和布林操作，都是挺簡單的。

```

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

// 這裡 COUNT_BITS 設定為 29(32-3)，意味著前三位用於存放執行緒狀態，後29位用於存放執行緒數
// 很多初學者很喜歡在自己的程式碼中寫很多 29 這種數字，或者某個特殊的字串，然後分佈在各個地方，這是非常糟糕的
private static final int COUNT_BITS = Integer.SIZE - 3;

// 000 11111111111111111111111111111
// 這裡得到的是 29 個 1，也就是說執行緒池的最大執行緒數是 2^29-1=536870911
// 以我們現在計算機的實際情況，這個數量還是夠用的
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

// 我們說了，執行緒池的狀態存放在高 3 位中
// 運算結果為 111跟29個0：111 00000000000000000000000000000
private static final int RUNNING    = -1 << COUNT_BITS;
// 000 00000000000000000000000000000
private static final int SHUTDOWN   =  0 << COUNT_BITS;
// 001 00000000000000000000000000000
private static final int STOP       =  1 << COUNT_BITS;
// 010 00000000000000000000000000000
private static final int TIDYING    =  2 << COUNT_BITS;
// 011 00000000000000000000000000000
private static final int TERMINATED =  3 << COUNT_BITS;

// 將整數 c 的低 29 位修改為 0，就得到了執行緒池的狀態
private static int runStateOf(int c)     { return c & ~CAPACITY; }
// 將整數 c 的高 3 為修改為 0，就得到了執行緒池中的執行緒數
private static int workerCountOf(int c)  { return c & CAPACITY; }

private static int ctlOf(int rs, int wc) { return rs | wc; }

/*
 * Bit field accessors that don't require unpacking ctl.
 * These depend on the bit layout and on workerCount being never negative.
 */

private static boolean runStateLessThan(int c, int s) {
    return c < s;
}

private static boolean runStateAtLeast(int c, int s) {
    return c >= s;
}

private static boolean isRunning(int c) {
    return c < SHUTDOWN;
}
```

上面就是對一個整數的簡單的位操作，幾個操作方法將會在後面的原始碼中一直出現，所以讀者最好把方法名字和其代表的功能記住，看原始碼的時候也就不需要來來回回翻了。

在這裡，介紹下執行緒池中的各個狀態和狀態變化的轉換過程：

*   RUNNING：這個沒什麼好說的，這是最正常的狀態：接受新的任務，處理等待佇列中的任務
*   SHUTDOWN：不接受新的任務提交，但是會繼續處理等待佇列中的任務
*   STOP：不接受新的任務提交，不再處理等待佇列中的任務，中斷正在執行任務的執行緒
*   TIDYING：所有的任務都銷燬了，workCount 為 0。執行緒池的狀態在轉換為 TIDYING 狀態時，會執行鉤子方法 terminated()
*   TERMINATED：terminated() 方法結束後，執行緒池的狀態就會變成這個

> RUNNING 定義為 -1，SHUTDOWN 定義為 0，其他的都比 0 大，所以等於 0 的時候不能提交任務，大於 0 的話，連正在執行的任務也需要中斷。

看了這幾種狀態的介紹，讀者大體也可以猜到十之八九的狀態轉換了，各個狀態的轉換過程有以下幾種：

*   RUNNING -> SHUTDOWN：當呼叫了 shutdown() 後，會發生這個狀態轉換，這也是最重要的
*   (RUNNING or SHUTDOWN) -> STOP：當呼叫 shutdownNow() 後，會發生這個狀態轉換，這下要清楚 shutDown() 和 shutDownNow() 的區別了
*   SHUTDOWN -> TIDYING：當任務佇列和執行緒池都清空後，會由 SHUTDOWN 轉換為 TIDYING
*   STOP -> TIDYING：當任務佇列清空後，發生這個轉換
*   TIDYING -> TERMINATED：這個前面說了，當 terminated() 方法結束後

上面的幾個記住核心的就可以了，尤其第一個和第二個。

另外，我們還要看看一個內部類 Worker，因為 Doug Lea 把執行緒池中的執行緒包裝成了一個個 Worker，翻譯成工人，就是執行緒池中做任務的執行緒。所以到這裡，我們知道**任務是 Runnable（內部變數名叫 task 或 command），執行緒是 Worker**。

Worker 這裡又用到了抽象類 AbstractQueuedSynchronizer。題外話，AQS 在併發中真的是到處出現，而且非常容易使用，寫少量的程式碼就能實現自己需要的同步方式（對 AQS 原始碼感興趣的讀者請參看我之前寫的幾篇文章）。

```
private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    private static final long serialVersionUID = 6138294804551838833L;

// 這個是真正的執行緒，任務靠你啦
    final Thread thread;

// 前面說了，這裡的 Runnable 是任務。為什麼叫 firstTask？因為在建立執行緒的時候，如果同時指定了
    // 這個執行緒起來以後需要執行的第一個任務，那麼第一個任務就是存放在這裡的(執行緒可不止執行這一個任務)
    // 當然了，也可以為 null，這樣執行緒起來了，自己到任務佇列（BlockingQueue）中取任務（getTask 方法）就行了
    Runnable firstTask;

// 用於存放此執行緒完成的任務數，注意了，這裡用了 volatile，保證可見性
    volatile long completedTasks;

// Worker 只有這一個構造方法，傳入 firstTask，也可以傳 null
    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        // 呼叫 ThreadFactory 來建立一個新的執行緒
        this.thread = getThreadFactory().newThread(this);
    }

// 這裡呼叫了外部類的 runWorker 方法
    public void run() {
        runWorker(this);
    }

...// 其他幾個方法沒什麼好看的，就是用 AQS 操作，來獲取這個執行緒的執行權，用了獨佔鎖
}
```

前面雖然囉嗦，但是簡單。有了上面的這些基礎後，我們終於可以看看 ThreadPoolExecutor 的 execute 方法了，前面原始碼分析的時候也說了，各種方法都最終依賴於 execute 方法：

```
public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();

// 前面說的那個表示 “執行緒池狀態” 和 “執行緒數” 的整數
    int c = ctl.get();

// 如果當前執行緒數少於核心執行緒數，那麼直接新增一個 worker 來執行任務，
    // 建立一個新的執行緒，並把當前任務 command 作為這個執行緒的第一個任務(firstTask)
    if (workerCountOf(c) < corePoolSize) {
        // 新增任務成功，那麼就結束了。提交任務嘛，執行緒池已經接受了這個任務，這個方法也就可以返回了
        // 至於執行的結果，到時候會包裝到 FutureTask 中。
        // 返回 false 代表執行緒池不允許提交任務
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 到這裡說明，要麼當前執行緒數大於等於核心執行緒數，要麼剛剛 addWorker 失敗了

// 如果執行緒池處於 RUNNING 狀態，把這個任務新增到任務佇列 workQueue 中
    if (isRunning(c) && workQueue.offer(command)) {
        /* 這裡面說的是，如果任務進入了 workQueue，我們是否需要開啟新的執行緒
         * 因為執行緒數在 [0, corePoolSize) 是無條件開啟新的執行緒
         * 如果執行緒數已經大於等於 corePoolSize，那麼將任務新增到佇列中，然後進到這裡
         */
        int recheck = ctl.get();
        // 如果執行緒池已不處於 RUNNING 狀態，那麼移除已經入隊的這個任務，並且執行拒絕策略
        if (! isRunning(recheck) && remove(command))
            reject(command);
        // 如果執行緒池還是 RUNNING 的，並且執行緒數為 0，那麼開啟新的執行緒
        // 到這裡，我們知道了，這塊程式碼的真正意圖是：擔心任務提交到佇列中了，但是執行緒都關閉了
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 如果 workQueue 佇列滿了，那麼進入到這個分支
    // 以 maximumPoolSize 為界建立新的 worker，
    // 如果失敗，說明當前執行緒數已經達到 maximumPoolSize，執行拒絕策略
    else if (!addWorker(command, false))
        reject(command);
}
```

> 對建立執行緒的錯誤理解：如果執行緒數少於 corePoolSize，建立一個執行緒，如果執行緒數在 [corePoolSize, maximumPoolSize] 之間那麼可以建立執行緒或複用空閒執行緒，keepAliveTime 對這個區間的執行緒有效。
> 
> 從上面的幾個分支，我們就可以看出，上面的這段話是錯誤的。

上面這些一時半會也不可能全部消化搞定，我們先繼續往下吧，到時候再回頭看幾遍。

這個方法非常重要 addWorker(Runnable firstTask, boolean core) 方法，我們看看它是怎麼建立新的執行緒的：

```
// 第一個引數是準備提交給這個執行緒執行的任務，之前說了，可以為 null
// 第二個引數為 true 代表使用核心執行緒數 corePoolSize 作為建立執行緒的界限，也就說建立這個執行緒的時候，
//         如果執行緒池中的執行緒總數已經達到 corePoolSize，那麼不能響應這次建立執行緒的請求
//         如果是 false，代表使用最大執行緒數 maximumPoolSize 作為界限
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

// 這個非常不好理解
        // 如果執行緒池已關閉，並滿足以下條件之一，那麼不建立新的 worker：
        // 1\. 執行緒池狀態大於 SHUTDOWN，其實也就是 STOP, TIDYING, 或 TERMINATED
        // 2\. firstTask != null
        // 3\. workQueue.isEmpty()
        // 簡單分析下：
        // 還是狀態控制的問題，當執行緒池處於 SHUTDOWN 的時候，不允許提交任務，但是已有的任務繼續執行
        // 當狀態大於 SHUTDOWN 時，不允許提交任務，且中斷正在執行的任務
        // 多說一句：如果執行緒池處於 SHUTDOWN，但是 firstTask 為 null，且 workQueue 非空，那麼是允許建立 worker 的
        // 這是因為 SHUTDOWN 的語義：不允許提交新的任務，但是要把已經進入到 workQueue 的任務執行完，所以在滿足條件的基礎上，是允許建立新的 Worker 的
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;

for (;;) {
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            // 如果成功，那麼就是所有建立執行緒前的條件校驗都滿足了，準備建立執行緒執行任務了
            // 這裡失敗的話，說明有其他執行緒也在嘗試往執行緒池中建立執行緒
            if (compareAndIncrementWorkerCount(c))
                break retry;
            // 由於有併發，重新再讀取一下 ctl
            c = ctl.get();
            // 正常如果是 CAS 失敗的話，進到下一個裡層的for迴圈就可以了
            // 可是如果是因為其他執行緒的操作，導致執行緒池的狀態發生了變更，如有其他執行緒關閉了這個執行緒池
            // 那麼需要回到外層的for迴圈
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

/* 
     * 到這裡，我們認為在當前這個時刻，可以開始建立執行緒來執行任務了，
     * 因為該校驗的都校驗了，至於以後會發生什麼，那是以後的事，至少當前是滿足條件的
     */

// worker 是否已經啟動
    boolean workerStarted = false;
    // 是否已將這個 worker 新增到 workers 這個 HashSet 中
    boolean workerAdded = false;
    Worker w = null;
    try {
        final ReentrantLock mainLock = this.mainLock;
        // 把 firstTask 傳給 worker 的構造方法
        w = new Worker(firstTask);
        // 取 worker 中的執行緒物件，之前說了，Worker的構造方法會呼叫 ThreadFactory 來建立一個新的執行緒
        final Thread t = w.thread;
        if (t != null) {
            // 這個是整個執行緒池的全域性鎖，持有這個鎖才能讓下面的操作“順理成章”，
            // 因為關閉一個執行緒池需要這個鎖，至少我持有鎖的期間，執行緒池不會被關閉
            mainLock.lock();
            try {

int c = ctl.get();
                int rs = runStateOf(c);

// 小於 SHUTTDOWN 那就是 RUNNING，這個自不必說，是最正常的情況
                // 如果等於 SHUTDOWN，前面說了，不接受新的任務，但是會繼續執行等待佇列中的任務
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    // worker 裡面的 thread 可不能是已經啟動的
                    if (t.isAlive())
                        throw new IllegalThreadStateException();
                    // 加到 workers 這個 HashSet 中
                    workers.add(w);
                    int s = workers.size();
                    // largestPoolSize 用於記錄 workers 中的個數的最大值
                    // 因為 workers 是不斷增加減少的，透過這個值可以知道執行緒池的大小曾經達到的最大值
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            // 新增成功的話，啟動這個執行緒
            if (workerAdded) {
                // 啟動執行緒
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        // 如果執行緒沒有啟動，需要做一些清理工作，如前面 workCount 加了 1，將其減掉
        if (! workerStarted)
            addWorkerFailed(w);
    }
    // 返回執行緒是否啟動成功
    return workerStarted;
}
```

簡單看下 addWorkFailed 的處理：

```
// workers 中刪除掉相應的 worker
// workCount 減 1
private void addWorkerFailed(Worker w) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (w != null)
            workers.remove(w);
        decrementWorkerCount();
        // rechecks for termination, in case the existence of this worker was holding up termination
        tryTerminate();
    } finally {
        mainLock.unlock();
    }
}
```

回過頭來，繼續往下走。我們知道，worker 中的執行緒 start 後，其 run 方法會呼叫 runWorker 方法：

```
// Worker 類的 run() 方法
public void run() {
    runWorker(this);
}
```

繼續往下看 runWorker 方法：

```
// 此方法由 worker 執行緒啟動後呼叫，這裡用一個 while 迴圈來不斷地從等待佇列中獲取任務並執行
// 前面說了，worker 在初始化的時候，可以指定 firstTask，那麼第一個任務也就可以不需要從佇列中獲取
final void runWorker(Worker w) {
    // 
    Thread wt = Thread.currentThread();
    // 該執行緒的第一個任務(如果有的話)
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        // 迴圈呼叫 getTask 獲取任務
        while (task != null || (task = getTask()) != null) {
            w.lock();          
            // 如果執行緒池狀態大於等於 STOP，那麼意味著該執行緒也要中斷
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                // 這是一個鉤子方法，留給需要的子類實現
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    // 到這裡終於可以執行任務了
                    task.run();
                } catch (RuntimeException x) {
                    thrown = x; throw x;
                } catch (Error x) {
                    thrown = x; throw x;
                } catch (Throwable x) {
                    // 這裡不允許丟擲 Throwable，所以轉換為 Error
                    thrown = x; throw new Error(x);
                } finally {
                    // 也是一個鉤子方法，將 task 和異常作為引數，留給需要的子類實現
                    afterExecute(task, thrown);
                }
            } finally {
                // 置空 task，準備 getTask 獲取下一個任務
                task = null;
                // 累加完成的任務數
                w.completedTasks++;
                // 釋放掉 worker 的獨佔鎖
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        // 如果到這裡，需要執行執行緒關閉：
        // 1\. 說明 getTask 返回 null，也就是說，佇列中已經沒有任務需要執行了，執行關閉
        // 2\. 任務執行過程中發生了異常
        // 第一種情況，已經在程式碼處理了將 workCount 減 1，這個在 getTask 方法分析中會說
        // 第二種情況，workCount 沒有進行處理，所以需要在 processWorkerExit 中處理
        // 限於篇幅，我不準備分析這個方法了，感興趣的讀者請自行分析原始碼
        processWorkerExit(w, completedAbruptly);
    }
}
```

我們看看 getTask() 是怎麼獲取任務的，這個方法寫得真的很好，每一行都很簡單，組合起來卻所有的情況都想好了：

```
// 此方法有三種可能：
// 1\. 阻塞直到獲取到任務返回。我們知道，預設 corePoolSize 之內的執行緒是不會被回收的，
//      它們會一直等待任務
// 2\. 超時退出。keepAliveTime 起作用的時候，也就是如果這麼多時間內都沒有任務，那麼應該執行關閉
// 3\. 如果發生了以下條件，此方法必須返回 null:
//    - 池中有大於 maximumPoolSize 個 workers 存在(透過呼叫 setMaximumPoolSize 進行設定)
//    - 執行緒池處於 SHUTDOWN，而且 workQueue 是空的，前面說了，這種不再接受新的任務
//    - 執行緒池處於 STOP，不僅不接受新的執行緒，連 workQueue 中的執行緒也不再執行
private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?

retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        // 兩種可能
        // 1\. rs == SHUTDOWN && workQueue.isEmpty()
        // 2\. rs >= STOP
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            // CAS 操作，減少工作執行緒數
            decrementWorkerCount();
            return null;
        }

boolean timed;      // Are workers subject to culling?
        for (;;) {
            int wc = workerCountOf(c);
            // 允許核心執行緒數內的執行緒回收，或當前執行緒數超過了核心執行緒數，那麼有可能發生超時關閉
            timed = allowCoreThreadTimeOut || wc > corePoolSize;

// 這裡 break，是為了不往下執行後一個 if (compareAndDecrementWorkerCount(c))
            // 兩個 if 一起看：如果當前執行緒數 wc > maximumPoolSize，或者超時，都返回 null
            // 那這裡的問題來了，wc > maximumPoolSize 的情況，為什麼要返回 null？
            //    換句話說，返回 null 意味著關閉執行緒。
            // 那是因為有可能開發者呼叫了 setMaximumPoolSize() 將執行緒池的 maximumPoolSize 調小了，那麼多餘的 Worker 就需要被關閉
            if (wc <= maximumPoolSize && ! (timedOut && timed))
                break;
            if (compareAndDecrementWorkerCount(c))
                return null;
            c = ctl.get();  // Re-read ctl
            // compareAndDecrementWorkerCount(c) 失敗，執行緒池中的執行緒數發生了改變
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
        // wc <= maximumPoolSize 同時沒有超時
        try {
            // 到 workQueue 中獲取任務
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            // 如果此 worker 發生了中斷，採取的方案是重試
            // 解釋下為什麼會發生中斷，這個讀者要去看 setMaximumPoolSize 方法。

// 如果開發者將 maximumPoolSize 調小了，導致其小於當前的 workers 數量，
            // 那麼意味著超出的部分執行緒要被關閉。重新進入 for 迴圈，自然會有部分執行緒會返回 null
            timedOut = false;
        }
    }
}
```

到這裡，基本上也說完了整個流程，讀者這個時候應該回到 execute(Runnable command) 方法，看看各個分支，我把程式碼貼過來一下：

```
public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();

// 前面說的那個表示 “執行緒池狀態” 和 “執行緒數” 的整數
    int c = ctl.get();

// 如果當前執行緒數少於核心執行緒數，那麼直接新增一個 worker 來執行任務，
    // 建立一個新的執行緒，並把當前任務 command 作為這個執行緒的第一個任務(firstTask)
    if (workerCountOf(c) < corePoolSize) {
        // 新增任務成功，那麼就結束了。提交任務嘛，執行緒池已經接受了這個任務，這個方法也就可以返回了
        // 至於執行的結果，到時候會包裝到 FutureTask 中。
        // 返回 false 代表執行緒池不允許提交任務
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 到這裡說明，要麼當前執行緒數大於等於核心執行緒數，要麼剛剛 addWorker 失敗了

// 如果執行緒池處於 RUNNING 狀態，把這個任務新增到任務佇列 workQueue 中
    if (isRunning(c) && workQueue.offer(command)) {
        /* 這裡面說的是，如果任務進入了 workQueue，我們是否需要開啟新的執行緒
         * 因為執行緒數在 [0, corePoolSize) 是無條件開啟新的執行緒
         * 如果執行緒數已經大於等於 corePoolSize，那麼將任務新增到佇列中，然後進到這裡
         */
        int recheck = ctl.get();
        // 如果執行緒池已不處於 RUNNING 狀態，那麼移除已經入隊的這個任務，並且執行拒絕策略
        if (! isRunning(recheck) && remove(command))
            reject(command);
        // 如果執行緒池還是 RUNNING 的，並且執行緒數為 0，那麼開啟新的執行緒
        // 到這裡，我們知道了，這塊程式碼的真正意圖是：擔心任務提交到佇列中了，但是執行緒都關閉了
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 如果 workQueue 佇列滿了，那麼進入到這個分支
    // 以 maximumPoolSize 為界建立新的 worker，
    // 如果失敗，說明當前執行緒數已經達到 maximumPoolSize，執行拒絕策略
    else if (!addWorker(command, false))
        reject(command);
}
```

上面各個分支中，有兩種情況會呼叫 reject(command) 來處理任務，因為按照正常的流程，執行緒池此時不能接受這個任務，所以需要執行我們的拒絕策略。接下來，我們說一說 ThreadPoolExecutor 中的拒絕策略。

```
final void reject(Runnable command) {
    // 執行拒絕策略
    handler.rejectedExecution(command, this);
}
```

此處的 handler 我們需要在構造執行緒池的時候就傳入這個引數，它是 RejectedExecutionHandler 的例項。

RejectedExecutionHandler 在 ThreadPoolExecutor 中有四個已經定義好的實現類可供我們直接使用，當然，我們也可以實現自己的策略，不過一般也沒有必要。

```
// 只要執行緒池沒有被關閉，那麼由提交任務的執行緒自己來執行這個任務。
public static class CallerRunsPolicy implements RejectedExecutionHandler {
    public CallerRunsPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }
    }
}

// 不管怎樣，直接丟擲 RejectedExecutionException 異常
// 這個是預設的策略，如果我們構造執行緒池的時候不傳相應的 handler 的話，那就會指定使用這個
public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                             " rejected from " +
                                             e.toString());
    }
}

// 不做任何處理，直接忽略掉這個任務
public static class DiscardPolicy implements RejectedExecutionHandler {
    public DiscardPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    }
}

// 這個相對霸道一點，如果執行緒池沒有被關閉的話，
// 把佇列隊頭的任務(也就是等待了最長時間的)直接扔掉，然後提交這個任務到等待佇列中
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    public DiscardOldestPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}
```

到這裡，ThreadPoolExecutor 的原始碼算是分析結束了。單純從原始碼的難易程度來說，ThreadPoolExecutor 的原始碼還算是比較簡單的，只是需要我們靜下心來好好看看罷了。

## Executors

這節其實也不是分析 Executors 這個類，因為它僅僅是工具類，它的所有方法都是 static 的。

*   生成一個固定大小的執行緒池：

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

最大執行緒數設定為與核心執行緒數相等，此時 keepAliveTime 設定為 0（因為這裡它是沒用的，即使不為 0，執行緒池預設也不會回收 corePoolSize 內的執行緒），任務佇列採用 LinkedBlockingQueue，無界佇列。

過程分析：剛開始，每提交一個任務都建立一個 worker，當 worker 的數量達到 nThreads 後，不再建立新的執行緒，而是把任務提交到 LinkedBlockingQueue 中，而且之後執行緒數始終為 nThreads。

*   生成只有**一個執行緒**的固定執行緒池，這個更簡單，和上面的一樣，只要設定執行緒數為 1 就可以了：

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

*   生成一個需要的時候就建立新的執行緒，同時可以複用之前建立的執行緒（如果這個執行緒當前沒有任務）的執行緒池：

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

核心執行緒數為 0，最大執行緒數為 Integer.MAX_VALUE，keepAliveTime 為 60 秒，任務佇列採用 SynchronousQueue。

這種執行緒池對於任務可以比較快速地完成的情況有比較好的效能。如果執行緒空閒了 60 秒都沒有任務，那麼將關閉此執行緒並從執行緒池中移除。所以如果執行緒池空閒了很長時間也不會有問題，因為隨著所有的執行緒都會被關閉，整個執行緒池不會佔用任何的系統資源。

過程分析：我把 execute 方法的主體黏貼過來，讓大家看得明白些。鑑於 corePoolSize 是 0，那麼提交任務的時候，直接將任務提交到佇列中，由於採用了 SynchronousQueue，所以如果是第一個任務提交的時候，offer 方法肯定會返回 false，因為此時沒有任何 worker 對這個任務進行接收，那麼將進入到最後一個分支來建立第一個 worker。之後再提交任務的話，取決於是否有空閒下來的執行緒對任務進行接收，如果有，會進入到第二個 if 語句塊中，否則就是和第一個任務一樣，進到最後的 else if 分支建立新執行緒。

```
int c = ctl.get();
// corePoolSize 為 0，所以不會進到這個 if 分支
if (workerCountOf(c) < corePoolSize) {
    if (addWorker(command, true))
        return;
    c = ctl.get();
}
// offer 如果有空閒執行緒剛好可以接收此任務，那麼返回 true，否則返回 false
if (isRunning(c) && workQueue.offer(command)) {
    int recheck = ctl.get();
    if (! isRunning(recheck) && remove(command))
        reject(command);
    else if (workerCountOf(recheck) == 0)
        addWorker(null, false);
}
else if (!addWorker(command, false))
    reject(command);
```

> SynchronousQueue 是一個比較特殊的 BlockingQueue，其本身不儲存任何元素，它有一個虛擬佇列（或虛擬棧），不管讀操作還是寫操作，如果當前佇列中儲存的是與當前操作相同模式的執行緒，那麼當前操作也進入佇列中等待；如果是相反模式，則配對成功，從當前佇列中取隊頭節點。具體的資訊，可以看我的另一篇關於 BlockingQueue 的文章。

## 總結

我一向不喜歡寫總結，因為我把所有需要表達的都寫在正文中了，寫小篇幅的總結並不能真正將話說清楚，本文的總結部分為準備面試的讀者而寫，希望能幫到面試者或者沒有足夠的時間看完全文的讀者。

1.  java 執行緒池有哪些關鍵屬性？

> corePoolSize，maximumPoolSize，workQueue，keepAliveTime，rejectedExecutionHandler
    > 
    > corePoolSize 到 maximumPoolSize 之間的執行緒會被回收，當然 corePoolSize 的執行緒也可以透過設定而得到回收（allowCoreThreadTimeOut(true)）。
    > 
    > workQueue 用於存放任務，新增任務的時候，如果當前執行緒數超過了 corePoolSize，那麼往該佇列中插入任務，執行緒池中的執行緒會負責到佇列中拉取任務。
    > 
    > keepAliveTime 用於設定空閒時間，如果執行緒數超出了 corePoolSize，並且有些執行緒的空閒時間超過了這個值，會執行關閉這些執行緒的操作
    > 
    > rejecte</runnable></runnable></runnable></runnable></runnable></runnable></t></t></t></t></t></t></t></void></t></t></future></t></future></future></t></future></t></t></future></t></t></t></future></future></t></future></t></t></t></t></t></t></t></t></t></t></future></future></t></t></t></t></t></t></t></t></t></void></t></t></t></t></t></t></t></v></t></t></t></t></t></t></t></future></t></t></future></t></t></t></t></t></t></runnable></runnable></runnable></runnable></runnable>

Java併發指南12：深度解讀 java 執行緒池設計思想及原始碼實現

相關文章