執行緒池是如何執行的？任務太多會怎樣？

Java 面試不可能不問執行緒池，無論是大廠還是小廠。這不，前幾天面試阿里時也被問到了這個問題，雖不難，但這裡也系統覆盤一下。

要搞懂執行緒池的執行流程，最好的方式是去看它的原始碼，它的原始碼如下：

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    int c = ctl.get();
    // 當前工作的執行緒數小於核心執行緒數
    if (workerCountOf(c) < corePoolSize) {
        // 建立新的執行緒執行此任務
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 檢查執行緒池是否處於執行狀態，如果是則把任務新增到佇列
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 再次檢執行緒池是否處於執行狀態，防止在第一次校驗通過後執行緒池關閉
        // 如果是非執行狀態，則將剛加入佇列的任務移除
        if (! isRunning(recheck) && remove(command))
            reject(command);
        // 如果執行緒池的執行緒數為 0 時（當 corePoolSize 設定為 0 時會發生）
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false); // 新建執行緒執行任務
    }
    // 核心執行緒都在忙且佇列都已爆滿，嘗試新啟動一個執行緒執行失敗
    else if (!addWorker(command, false)) 
        // 執行拒絕策略
        reject(command);
}

從上述原始碼我們可以看出，當任務來了之後，執行緒池的執行流程是：先判斷當前執行緒數是否大於核心執行緒數？如果結果為 false，則新建執行緒並執行任務；如果結果為 true，則判斷任務佇列是否已滿？如果結果為 false，則把任務新增到任務佇列中等待執行緒執行，否則則判斷當前執行緒數量是否超過最大執行緒數？如果結果為 false，則新建執行緒執行此任務，否則將執行執行緒池的拒絕策略，如下圖所示：

執行緒池拒絕策略

當任務過多且執行緒池的任務佇列已滿時，此時就會執行執行緒池的拒絕策略，執行緒池的拒絕策略預設有以下 4 種：

1. AbortPolicy：中止策略，執行緒池會丟擲異常並中止執行此任務；
2. CallerRunsPolicy：把任務交給新增此任務的（main）執行緒來執行；
3. DiscardPolicy：忽略此任務，忽略最新的一個任務；
4. DiscardOldestPolicy：忽略最早的任務，最先加入佇列的任務。

預設的拒絕策略為 AbortPolicy 中止策略。

DiscardPolicy拒絕策略

接下來我們以 DiscardPolicy 忽略此任務，忽略最新的一個任務為例，演示一下拒絕策略的具體使用，實現程式碼如下：

public static void main(String[] args) {
    // 任務的具體方法
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("當前任務被執行,執行時間:" + new Date() +
                               " 執行執行緒:" + Thread.currentThread().getName());
            try {
                // 等待 1s
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
    // 建立執行緒,執行緒的任務佇列的長度為 1
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1,
                                                           100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1),
                                                           new ThreadPoolExecutor.DiscardPolicy());
    // 新增並執行 4 個任務
    threadPool.execute(runnable);
    threadPool.execute(runnable);
    threadPool.execute(runnable);
    threadPool.execute(runnable);
    // 執行緒池執行完任務，關閉執行緒池
    threadPool.shutdown();
}

以上程式的執行結果如下：

從上述執行結果可以看出，給執行緒池新增了 4 個任務，而執行緒池只執行了 2 個任務就結束了，其他兩個任務執行了拒絕策略 DiscardPolicy 被忽略了，這就是拒絕策略的作用。

AbortPolicy拒絕策略

為了和 DiscardPolicy 拒絕策略對比，我們來演示一下 JDK 預設的拒絕策略 AbortPolicy 中止策略，執行緒池會丟擲異常並中止執行此任務，範例程式碼如下：

public static void main(String[] args) {
    // 任務的具體方法
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("當前任務被執行,執行時間:" + new Date() +
                               " 執行執行緒:" + Thread.currentThread().getName());
            try {
                // 等待 1s
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
    // 建立執行緒,執行緒的任務佇列的長度為 1
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1,
                                                           100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1),
                                                           new ThreadPoolExecutor.AbortPolicy()); // 顯式指定拒絕策略，也可以忽略此設定，它為預設拒絕策略
    // 新增並執行 4 個任務
    threadPool.execute(runnable);
    threadPool.execute(runnable);
    threadPool.execute(runnable);
    threadPool.execute(runnable);
    // 執行緒池執行完任務，關閉執行緒池
    threadPool.shutdown();
}

以上程式的執行結果如下：

從結果可以看出，給執行緒池新增了 4 個任務，執行緒池正常執行了 2 個任務，其他兩個任務執行了中止策略，並丟擲了拒絕執行的異常 RejectedExecutionException。

自定義拒絕策略

當然除了 JDK 提供的四種拒絕策略之外，我們還可以實現通過 new RejectedExecutionHandler，並重寫 rejectedExecution 方法來實現自定義拒絕策略，實現程式碼如下：

public static void main(String[] args) {
    // 任務的具體方法
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("當前任務被執行,執行時間:" + new Date() +
                               " 執行執行緒:" + Thread.currentThread().getName());
            try {
                // 等待 1s
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
    // 建立執行緒,執行緒的任務佇列的長度為 1
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1,
                                                           100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1),
                                                           new RejectedExecutionHandler() {
                                                               @Override
                                                               public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                                                                   // 執行自定義拒絕策略的相關操作
                                                                   System.out.println("我是自定義拒絕策略~");
                                                               }
                                                           });
    // 新增並執行 4 個任務
    threadPool.execute(runnable);
    threadPool.execute(runnable);
    threadPool.execute(runnable);
    threadPool.execute(runnable);
}

以上程式的執行結果如下：

小結

執行緒池的執行流程有 3 個重要的判斷點（判斷順序依次往後）：判斷當前執行緒數和核心執行緒數、判斷當前任務佇列是否已滿、判斷當前執行緒數是否已達到最大執行緒數。如果經過以上 3 個判斷，得到的結果都會 true，則會執行執行緒池的拒絕策略。JDK 提供了 4 種拒絕策略，我們還可以通過 new RejectedExecutionHandler 並重寫 rejectedExecution 方法來實現自定義拒絕策略。

本文已收錄至《Java面試突擊》，專注 Java 面試 100 年，檢視更多：www.javacn.site