2. 程式人生 > >Java並發（五）線程池使用番外-分析RejectedExecutionException異常

Java並發（五）線程池使用番外-分析RejectedExecutionException異常

阿新 • • 發佈：2019-04-22
讓我 seconds ride 產生 程序 i++ 接下來 異常 override

目錄

　　一、入門示例

　　二、異常場景1

　　三、異常場景2

　　四、解決方法

之前在使用線程池的時候，出現了 java.util.concurrent.RejectedExecutionException ，原因是線程池配置不合理，導致提交的任務來不及處理。接下來用一個簡單的例子來復現異常。

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task [email protected] rejected from [email protected][Running, pool size = 3, active threads = 3, queued tasks = 15, completed tasks = 0]
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:
 
2047)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
    at org.cellphone.common.pool.RejectedExecutionExceptionExample.main(RejectedExecutionExceptionExample.java:22)

一、入門示例

下面的測試程序使用 ThreadPoolExecutor 類來創建線程池執行任務，代表任務 Worker 類代碼如下：

/**
 * Created by on 2019/4/20.
 */
public class Worker implements Runnable {

    private int id;

    public Worker(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName() 
 
+ " 執行任務 " + id);
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " 完成任務 " + id);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

執行 Worker 任務的代碼如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created by on 2019/4/20.
 */
public class RejectedExecutionExceptionExample {

    public static void main(String[] args) {

        ExecutorService executor = new ThreadPoolExecutor(3, 3, 0L,
                TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(15));

        Worker tasks[] = new Worker[10];
        for (int i = 0; i < 10; i++) {
            tasks[i] = new Worker(i);
            System.out.println("提交任務: " + tasks[i] + ", " + i);
            executor.execute(tasks[i]);
        }
        System.out.println("主線程結束");
        executor.shutdown();    // 關閉線程池
    }
}

運行一下，看到如下輸出：

提交任務: [email protected], 0
提交任務: [email protected], 1
提交任務: [email protected], 2
提交任務: [email protected], 3
提交任務: [email protected], 4
提交任務: [email protected], 5
提交任務: [email protected], 6
提交任務: [email protected], 7
提交任務: [email protected], 8
提交任務: [email protected], 9
主線程結束
pool-1-thread-1 執行任務 0
pool-1-thread-2 執行任務 1
pool-1-thread-3 執行任務 2
pool-1-thread-1 完成任務 0
pool-1-thread-1 執行任務 3
pool-1-thread-2 完成任務 1
pool-1-thread-2 執行任務 4
pool-1-thread-3 完成任務 2
pool-1-thread-3 執行任務 5
pool-1-thread-2 完成任務 4
pool-1-thread-2 執行任務 6
pool-1-thread-3 完成任務 5
pool-1-thread-1 完成任務 3
pool-1-thread-3 執行任務 7
pool-1-thread-1 執行任務 8
pool-1-thread-3 完成任務 7
pool-1-thread-2 完成任務 6
pool-1-thread-1 完成任務 8
pool-1-thread-2 執行任務 9
pool-1-thread-2 完成任務 9

在 RejectedExecutionExceptionExample 類裏，我們使用 ThreadPoolExecutor 類創建了一個數量為3的線程池來執行任務，在這3個線程執行任務被占用期間，如果有新任務提交給線程池，那麽這些新任務會被保存在 BlockingQueue 阻塞隊列裏，以等待被空閑線程取出並執行。在這裏我們使用一個大小為15的 ArrayBlockingQueue 隊列來保存待執行的任務，然後我們創建了10個任務提交給 ThreadPoolExecutor 線程池。

二、異常場景1

產生 RejectedExecutionException 異常的第一個原因：

調用 shutdown() 方法關閉了 ThreadPoolExecutor 線程池，又提交新任務給 ThreadPoolExecutor 線程池執行。一般調用 shutdown() 方法之後，JVM會得到一個關閉線程池的信號，並不會立即關閉線程池，原來線程池裏未執行完的任務仍然在執行，等到任務都執行完後才關閉線程池，但是JVM不允許再提交新任務給線程池。

讓我們用以下例子來重現該異常：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created by on 2019/4/20.
 */
public class RejectedExecutionExceptionExample {

    public static void main(String[] args) {

        ExecutorService executor = new ThreadPoolExecutor(3, 3, 0L,
                TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(15));

        Worker tasks[] = new Worker[10];
        for (int i = 0; i < 10; i++) {
            tasks[i] = new Worker(i);
            System.out.println("提交任務: " + tasks[i] + ", " + i);
            executor.execute(tasks[i]);
        }
        System.out.println("主線程結束");
        executor.shutdown();// 關閉線程池
        executor.execute(tasks[0]);// 關閉線程池之後提交新任務，運行之後拋異常
    }
}

運行一下，看到如下輸出：

提交任務: [email protected], 0
提交任務: [email protected], 1
提交任務: [email protected], 2
提交任務: [email protected], 3
提交任務: [email protected], 4
提交任務: [email protected], 5
提交任務: [email protected], 6
提交任務: [email protected], 7
提交任務: [email protected], 8
提交任務: [email protected], 9
主線程結束
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task [email protected] rejected from [email protected][Shutting down, pool size = 3, active threads = 3, queued tasks = 7, completed tasks = 0]
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
    at org.cellphone.common.pool.RejectedExecutionExceptionExample.main(RejectedExecutionExceptionExample.java:26)
pool-1-thread-1 執行任務 0
pool-1-thread-2 執行任務 1
pool-1-thread-3 執行任務 2
pool-1-thread-1 完成任務 0
pool-1-thread-1 執行任務 3
pool-1-thread-2 完成任務 1
pool-1-thread-2 執行任務 4
pool-1-thread-3 完成任務 2
pool-1-thread-3 執行任務 5
pool-1-thread-3 完成任務 5
pool-1-thread-3 執行任務 6
pool-1-thread-2 完成任務 4
pool-1-thread-2 執行任務 7
pool-1-thread-1 完成任務 3
pool-1-thread-1 執行任務 8
pool-1-thread-3 完成任務 6
pool-1-thread-2 完成任務 7
pool-1-thread-3 執行任務 9
pool-1-thread-1 完成任務 8
pool-1-thread-3 完成任務 9

從以上例子可以看出，在調用 shutdown() 方法之後，由於JVM不允許再提交新任務給線程池，於是拋出了 RejectedExecutionException 異常。

三、異常場景2

產生 RejectedExecutionException 異常第二個原因：

要提交給阻塞隊列的任務超出了該隊列的最大容量。當線程池裏的線程都繁忙的時候，新任務會被提交給阻塞隊列保存，這個阻塞隊列一旦飽和，線程池就會拒絕接收新任務，隨即拋出異常。

示例代碼如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created by on 2019/4/20.
 */
public class RejectedExecutionExceptionExample {

    public static void main(String[] args) {

        ExecutorService executor = new ThreadPoolExecutor(3, 3, 0L,
                TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(15));

        // 提交20個任務給線程池
        Worker tasks[] = new Worker[20];
        for (int i = 0; i < 20; i++) {
            tasks[i] = new Worker(i);
            System.out.println("提交任務: " + tasks[i] + ", " + i);
            executor.execute(tasks[i]);
        }
        System.out.println("主線程結束");
        executor.shutdown();// 關閉線程池
    }
}

在上面的例子中，我們使用了一個大小為15的 ArrayBlockingQueue 阻塞隊列來保存等待執行的任務。接著我們提交了20個任務給線程池，由於每個線程執行任務的時候會睡眠1秒，因此當3個線程繁忙的時候，其他任務不會立即得到執行，我們提交的新任務會被保存在隊列裏。當等待任務的數量超過線程池阻塞隊列的最大容量時，拋出了 RejectedExecutionException 異常。

四、解決方法

要解決 RejectedExecutionException 異常，首先我們要註意兩種情況：

  1. 當調用了線程池的shutdown()方法以後，不要提交新任務給線程池
  2. 不要提交大量超過線程池處理能力的任務，這時可能會導致隊列飽和，拋出異常

對於第二種情況，我們很容易解決。我們可以選擇一種不需要設置大小限制的數據結構，比如 LinkedBlockingQueue 阻塞隊列。因此在使用 LinkedBlockingQueue 隊列以後，如果還出現 RejectedExecutionException 異常，就要將問題的重點放在第一種情況上。如果第一種情況不是產生問題的原因，那麽我們還需要尋找更復雜的原因。比如，由於線程死鎖和 LinkedBlockingQueue 飽和，導致內存占用過大，這個時候我們就需要考慮JVM可用內存的問題了。

對於第二種情況，通常有一些隱藏的信息被我們忽略。其實我們可以給使用 ArrayBlockingQueue 作為阻塞隊列的 ThreadPoolExecutor 線程池提交超過15個的任務，只要我們在提交新任務前設置一個完成原來任務的等待時間，這時3個線程就會逐漸消費 ArrayBlockingQueue 阻塞隊列裏的任務，而不會使它堵塞。示例如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created by on 2019/4/20.
 */
public class RejectedExecutionExceptionExample {

    public static void main(String[] args) throws InterruptedException {

        ExecutorService executor = new ThreadPoolExecutor(3, 3, 0L,
                TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(15));

        // 提交20個任務給線程池
        Worker tasks[] = new Worker[20];
        for (int i = 0; i < 10; i++) {
            tasks[i] = new Worker(i);
            System.out.println("提交任務: " + tasks[i] + ", " + i);
            executor.execute(tasks[i]);
        }

        Thread.sleep(3000);// 讓主線程睡眠三秒
        for (int i = 10; i < 20; i++) {
            tasks[i] = new Worker(i);
            System.out.println("提交任務: " + tasks[i] + ", " + i);
            executor.execute(tasks[i]);
        }

        System.out.println("主線程結束");
        executor.shutdown();// 關閉線程池
    }
}

運行一下，看到如下輸出：

提交任務: org.cellphon[email protected], 0
提交任務: [email protected], 1
提交任務: [email protected], 2
提交任務: [email protected], 3
提交任務: [email protected], 4
提交任務: [email protected], 5
提交任務: [email protected], 6
提交任務: [email protected], 7
提交任務: [email protected], 8
提交任務: [email protected], 9
pool-1-thread-1 執行任務 0
pool-1-thread-2 執行任務 1
pool-1-thread-3 執行任務 2
pool-1-thread-2 完成任務 1
pool-1-thread-3 完成任務 2
pool-1-thread-1 完成任務 0
pool-1-thread-3 執行任務 4
pool-1-thread-2 執行任務 3
pool-1-thread-1 執行任務 5
pool-1-thread-3 完成任務 4
pool-1-thread-3 執行任務 6
pool-1-thread-2 完成任務 3
pool-1-thread-2 執行任務 7
pool-1-thread-1 完成任務 5
pool-1-thread-1 執行任務 8
提交任務: [email protected], 10
提交任務: [email protected], 11
提交任務: [email protected], 12
提交任務: [email protected], 13
提交任務: [email protected], 14
提交任務: [email protected], 15
提交任務: [email protected], 16
提交任務: [email protected], 17
提交任務: [email protected], 18
pool-1-thread-3 完成任務 6
pool-1-thread-2 完成任務 7
pool-1-thread-1 完成任務 8
pool-1-thread-2 執行任務 10
pool-1-thread-3 執行任務 9
提交任務: [email protected], 19
pool-1-thread-1 執行任務 11
主線程結束
pool-1-thread-2 完成任務 10
pool-1-thread-2 執行任務 12
pool-1-thread-1 完成任務 11
pool-1-thread-1 執行任務 13
pool-1-thread-3 完成任務 9
pool-1-thread-3 執行任務 14
pool-1-thread-2 完成任務 12
pool-1-thread-2 執行任務 15
pool-1-thread-3 完成任務 14
pool-1-thread-3 執行任務 16
pool-1-thread-1 完成任務 13
pool-1-thread-1 執行任務 17
pool-1-thread-2 完成任務 15
pool-1-thread-2 執行任務 18
pool-1-thread-3 完成任務 16
pool-1-thread-1 完成任務 17
pool-1-thread-3 執行任務 19
pool-1-thread-2 完成任務 18
pool-1-thread-3 完成任務 19

當然上面這種設置等待時間來分隔舊任務和新任務的方式，在高並發情況下效率並不高，一方面由於我們無法準確預估等待時間，一方面由於 ArrayBlockingQueue 內部只使用了一個鎖來隔離讀和寫的操作，因此效率沒有使用了兩個鎖來隔離讀寫操作的 LinkedBlockingQueue 高，故而不推薦使用這種方式。

Java並發（五）線程池使用番外-分析RejectedExecutionException異常

相關推薦

Java並發（五）線程池使用番外-分析RejectedExecutionException異常

讓我 seconds ride 產生 程序 i++ 接下來 異常 override 目錄 　　一、入門示例 　　二、異常場景1 　　三、異常場景2 　　四、解決方法 之前在使用線程池的時候，出現了 java.util.concurrent.RejectedE

Java並發（六）線程池監控

可用性 completed 越來越大 keep incr 構造 日誌 開發 task 目錄 　　一、線程池監控參數 　　二、線程池監控類 　　三、註意事項 在上一篇博文中，我們介紹了線程池的基本原理和使用方法。了解了基本概念之後，我們可以使用 Executor

Java並發（一）——線程安全的容器（上）

med ole 復雜 出隊 表示 就是 nsh 附加 構造方法 Java中線程安全的容器主要包括兩類： Vector、Hashtable，以及封裝器類Collections.synchronizedList和Collections.synchronizedMap； Jav

java高並發編程（五）線程池

pen style shutdown return turn lock close print dfa 摘自馬士兵java並發編程 一、認識Executor、ExecutorService、Callable、Executors /** * 認識Executor */

java基礎回顧（五）線程詳解以及synchronized關鍵字

dom com stack 相互 ++ 關於 而是 。。 str 本文將從線程的使用方式、源碼、synchronized關鍵字的使用方式和陷阱以及一些例子展開java線程和synchronized關鍵字的內容。 一、線程的概念 線程就是程序中單獨順序的流控制。線程本 身不能

Java面試題（五）線程及集合補充

每一個 場景 nds 試題 個數 安全 應用程序 -- 服務器 1,一個進程就是一個應用程序。一個線程就是一個進程中運行的最小單元。 一個進程可以包括多線程。 餐館(進程)。 主線程。 服務員(線程) 服務員(線程) 服務員(線程) 服務員(線程) 加塞，讓步，守護，

多線程（五）--線程池的基本使用

最大 col 單線程 out cut cond thread let inter 一、線程池（ThreadPoolExecutor）的創建 ThreadPoolExecutor內部的構造函數只有四種 public ThreadPoolExecutor(i

Java多線程和並發（五），線程的狀態

font lis ont 等待 strong info 目錄 list 線程的狀態 目錄 1.線程的六個狀態 2.sleep和wait的區別 3.鎖池（EntryList）和等待池（WaitSet） 4.notify和notifyall的區別 五、線程的狀態 1.線程的六個

Java並發編程實踐讀書筆記（5） 線程池的使用

設計 java並發編程 指定 數據交換 什麽 讀書 body 發展 ima Executor與Task的耦合性 1，除非線程池很非常大，否則一個Task不要依賴同一個線程服務中的另外一個Task，因為這樣容易造成死鎖； 2，線程的執行是並行的，所以在設計Task的時候要考慮

Java並發（一）-了解線程安全

println 發現 java並發編程 發的 for 混合 private 和我 情況 線程不安全性 先來舉例說明線程不安全是什麽情況下發生的：例如一個變量可以被多個線程進行訪問，那麽在大量線程並發訪問這個變量的情況下，線程執行的順序會給最後的結果帶來不可預估的錯誤。 先定

Java並發（一）並發編程的挑戰

來替 發包 empty oss ted tac 影響 答案 str 並發編程的目的是為了讓程序運行得更快，但是，並不是啟動更多的線程就能讓程序最大限度地並發執行。在進行並發編程時，如果希望通過多線程執行任務讓程序運行得更快，會面臨非常多的挑戰，比如上下文切換的問題、死鎖的問

Java並發性和多線程介紹

多任務 其中 介紹 tar 時間 分布 發生 自己 一定的 以下內容轉自http://ifeve.com/java-concurrency-thread/： 在過去單CPU時代，單任務在一個時間點只能執行單一程序。之後發展到多任務階段，計算機能在同一時間點並行執行多任務或

5、Java並發性和多線程-相同線程

http 主題 數據位 thread 分片 內部 自己的 .cn 同時 以下內容轉自http://tutorials.jenkov.com/java-concurrency/same-threading.html（使用谷歌翻譯）： 相同線程（同一線程）是一種並發模型，其中

14、Java並發性和多線程-Java ThreadLocal

run main eric eas 返回值 ins 存儲 sys protected 以下內容轉自http://ifeve.com/java-theadlocal/： Java中的ThreadLocal類可以讓你創建的變量只被同一個線程進行讀和寫操作。因此，盡管有兩個線程

13、Java並發性和多線程-Java Volatile關鍵字

也不會 深入 spa 程序 dex bsp 谷歌 .cn new 以下內容轉自http://tutorials.jenkov.com/java-concurrency/volatile.html（使用谷歌翻譯）： Java volatile關鍵字用於將Java變量標記為&

18、Java並發性和多線程-饑餓與公平

cnblogs 同步鎖 丟失 允許 color dex 訪問 嵌套 時間 以下內容轉自http://ifeve.com/starvation-and-fairness/： 如果一個線程因為CPU時間全部被其他線程搶走而得不到CPU運行時間，這種狀態被稱之為“饑

21、Java並發性和多線程-Java中的鎖

介紹 new 現在 lan 返回 som pan 同步機制 col 以下內容轉自http://ifeve.com/locks/： 鎖像synchronized同步塊一樣，是一種線程同步機制，但比Java中的synchronized同步塊更復雜。因為鎖（以及其它更高級的線程

22、Java並發性和多線程-Java中的讀/寫鎖

權限 原理 目的 str sco readers 閱讀 操作 wait 以下內容轉自http://ifeve.com/read-write-locks/： 相比Java中的鎖(Locks in Java)裏Lock實現，讀寫鎖更復雜一些。假設你的程序中涉及到對一些共享資源

25、Java並發性和多線程-阻塞隊列

多線程 throws clas cep ted this return exception exceptio 以下內容轉自http://ifeve.com/blocking-queues/： 阻塞隊列與普通隊列的區別在於，當隊列是空的時，從隊列中獲取元素的操作將會被阻塞，

30、Java並發性和多線程-阿姆達爾定律

開發者 dup 算術 currency 優化 blog 進行 變量 自己的 以下內容轉自http://ifeve.com/amdahls-law/： 阿姆達爾定律可以用來計算處理器平行運算之後效率提升的能力。阿姆達爾定律因Gene Amdal 在1967年提出這個定律而得