2. 程式人生 > >執行緒池--拒絕策略RejectedExecutionHandler 原理和實驗

執行緒池--拒絕策略RejectedExecutionHandler 原理和實驗

阿新 • • 發佈：2018-11-11

 

當執行緒池的任務快取佇列已滿並且執行緒池中的執行緒數目達到maximumPoolSize，如果還有任務到來就會採取任務拒絕策略，通常有以下四種策略：

ThreadPoolExecutor.AbortPolicy:丟棄任務並丟擲RejectedExecutionException異常。 預設策略

ThreadPoolExecutor.DiscardPolicy：也是丟棄任務，但是不丟擲異常。 

ThreadPoolExecutor.DiscardOldestPolicy：丟棄佇列最前面的任務，然後重新嘗試執行任務（重複此過程） 

ThreadPoolExecutor.CallerRunsPolicy：由呼叫執行緒處理該任務

下面來看幾個例子：

1. AbortPolicy策略:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.RejectedExecutionException;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

 

public class AbortPolicyDemo { 

    private static final int THREADS_SIZE = 1; 

    private static final int CAPACITY = 1; 

    public static

 void main(String[] args) throws Exception {

        // 建立執行緒池。執行緒池的"最大池大小"和"核心池大小"都為1(THREADS_SIZE)，"執行緒池"的阻塞佇列容量為1(CAPACITY)。 

        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(CAPACITY)); 

        // 設定執行緒池的拒絕策略為"丟擲異常" 

        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy()); 

        try {

            // 新建10個任務，並將它們新增到執行緒池中。 

            for (int i = 0; i < 10; i++) {

                Runnable myrun = new MyRunnable("task-"+i);

                pool.execute(myrun);

            } 

        }catch (RejectedExecutionException e) {

            e.printStackTrace(); 

           // 關閉執行緒池

            pool.shutdown();

        } 

        }

}

輸出：

task-0 is running.

java.util.concurrent.RejectedExecutionException: Task [email protected] rejected from [email protected][Running, pool size = 1, active threads = 1, queued tasks = 1, completed tasks = 0]

at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)

at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)

at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)

at AbortPolicyDemo.main(AbortPolicyDemo.java:18)

task-1 is running.

結果分析：

先是task0佔有了唯一的執行緒執行額度並開始執行，隨後task1佔有阻塞佇列的唯一空間，隨後task2想執行，發現task0還沒跑完，執行額度又滿了，於是嘗試進入阻塞佇列，結果發現阻塞佇列被task1給佔了，無路可走的task2於是丟擲異常，關閉執行緒池。

 

2.DiscardPolicy策略：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

 

class MyRunnable implements Runnable {

    private String name;

    public MyRunnable(String name) {

        this.name = name;

    }

    @Override

    public void run() {

        try {

            System.out.println(this.name + " is running.");

            Thread.sleep(100);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

 

public class DiscardPolicyDemo

{

    private static final int THREADS_SIZE = 1;

    private static final int CAPACITY = 1;

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

        // 建立執行緒池。執行緒池的"最大池大小"和"核心池大小"都為1(THREADS_SIZE)，"執行緒池"的阻塞佇列容量為1(CAPACITY)。

        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(CAPACITY));

        // 設定執行緒池的拒絕策略為"丟棄"

        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());

        // 新建10個任務，並將它們新增到執行緒池中。

        for (int i = 0; i < 10; i++) {

            Runnable myrun = new MyRunnable("task-"+i);

            pool.execute(myrun);

        }

        // 關閉執行緒池

        pool.shutdown();

    }

}

輸出結果：

task-0 is running.

task-1 is running.

結果分析:

執行緒池的第一個引數決定可以併發幾個執行緒，這裡設為1，那麼就表示執行緒只能一個一個來，另一個引數是最後這個ArrayBlockingQueue所代表的，意思是如果新提交到執行緒池的執行緒如果當前沒有執行額度（例如上面這種一次只能執行1個執行緒，我這裡就暫稱為執行額度為1），那麼只能放到這個阻塞佇列中等待，而阻塞佇列本身也是有大小的，所以也會滿，滿了怎麼辦，就對應上面說的四種策略，所以上面的程式碼如果在33行後加一行Thread.sleep(200);則10個執行緒都能得到執行，因為上面設定了每個執行緒的執行時間為100毫秒，那麼只要等超過100毫秒的時間，執行緒就會執行完畢並釋放資源，則後序提交的執行緒就來得及進入執行緒池，否則像上面的程式碼那樣太急著提交，直接就會導致阻塞的發生，從而觸發拒絕策略。

 

3. DiscardOldestPolicy策略：

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

 

 

 

public class DiscardOldestPolicyDemo

{

    private static final int THREADS_SIZE = 1;

    private static final int CAPACITY = 1;

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

        // 建立執行緒池。執行緒池的"最大池大小"和"核心池大小"都為1(THREADS_SIZE)，"執行緒池"的阻塞佇列容量為1(CAPACITY)。

        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(CAPACITY));

        // 設定執行緒池的拒絕策略為"DiscardOldestPolicy"

        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());

        // 新建10個任務，並將它們新增到執行緒池中。

        for (int i = 0; i < 10; i++) {

            Runnable myrun = new MyRunnable("task-"+i);

            pool.execute(myrun);

        }

        // 關閉執行緒池

        pool.shutdown(); }

}

輸出結果為：

task-0 is running.

 

task-9 is running.

結果分析：

可見1到8都被擠掉了，推演如下：先task0進入開始執行200ms，在這200ms內，發生瞭如下後序事件：task1進入阻塞佇列等待，task2想進入阻塞佇列，但是發現task1佔著茅坑，於是把它擠出去，取而代之，task3想進入阻塞佇列，又發現task2佔著茅坑，於是把它擠出去，取而代之，以此類推，最終task-9佔據了阻塞佇列的位置，並等task0完成後task9開始執行。於是乎有了上面的輸出。

 

4. CallerRunsPolicy

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

 

public class CallerRunsPolicyDemo {

    private static final int THREADS_SIZE = 1;

    private static final int CAPACITY = 1;

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

        // 建立執行緒池。執行緒池的"最大池大小"和"核心池大小"都為1(THREADS_SIZE)，"執行緒池"的阻塞佇列容量為1(CAPACITY)。

        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(CAPACITY));

        // 設定執行緒池的拒絕策略為"CallerRunsPolicy"

        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        // 新建10個任務，並將它們新增到執行緒池中。

        for (int i = 0; i < 10; i++) {

            Runnable myrun = new MyRunnable("task-"+i); pool.execute(myrun);

        }

        // 關閉執行緒池

        pool.shutdown();

    }

}

結果：

task-2 is running.

task-0 is running.

task-3 is running.

task-1 is running.

task-5 is running.

task-4 is running.

task-7 is running.

task-6 is running.

task-9 is running.

 

task-8 is running.

結果分析：

首先，所有的人物都得到了執行，沒有一個被漏掉或者丟擲異常什麼的，其次，注意到順序看起來亂七八糟，但是仔細看還是亂中有序，可以這樣理解：相當於現在有三個槽，一個是執行執行緒空間，一個是阻塞佇列，一個是主執行緒，前兩個槽視為一個整體，這個整體跟主執行緒的槽對比，誰有空，執行緒就進入誰，最終可以決定執行的順序。

相關推薦

執行緒池--拒絕策略RejectedExecutionHandler 原理和實驗

  當執行緒池的任務快取佇列已滿並且執行緒池中的執行緒數目達到maximumPoolSize，如果還有任務到來就會採取任務拒絕策略，通常有以下四種策略： ThreadPoolExecutor.AbortPolicy:丟棄任務並丟擲RejectedExecutionException

Java併發程式設計：Java執行緒池核心ThreadPoolExecutor的使用和原理分析

引出執行緒池 執行緒是併發程式設計的基礎，前面的文章裡，我們的例項基本都是基於執行緒開發作為例項，並且都是使用的時候就建立一個執行緒。這種方式比較簡單，但是存在一個問題，那就是執行緒的數量問題。 假設有一個系統比較複雜，需要的執行緒數很多，如果都是採用這種方式來建立執行緒的話，那麼就會極大的消耗系統資源。

java執行緒池（有返回值和無返回值）

無返回值： package ThreadPool2; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class test { public stat

【小家java】Java執行緒池之---ForkJoinPool執行緒池的使用以及原理

相關閱讀 【小家java】java5新特性（簡述十大新特性） 重要一躍 【小家java】java6新特性（簡述十大新特性） 雞肋升級 【小家java】java7新特性（簡述八大新特性） 不溫不火 【小家java】java8新特性（簡述十大新特性） 飽受讚譽 【小家java】java9

執行緒池 (4)---構造,析構和宣告 (附帶一個測試main)

先上程式碼,宣告部分 1 #ifndef _THREAD_POOL_ 2 #define _THREAD_POOL_ 3 4 #pragma once 5 6 #include<thread> 7 #include<condition_variable

socket+執行緒池，寫服務端和客戶端進行互動

以下內容轉自： https://www.cnblogs.com/gnoc/p/4866788.html 前言　　 socket（套接字），Socket和ServerSocket位於java.net包中，持續開啟服務端，接收來自客戶端的資訊，並響應。 最開始，咱們先來兩段最簡單的服

Java多執行緒-----執行緒池的使用，原理以及舉例實現（三）（四）：使用樣例及如何配置執行緒池大小

三.使用示例 　　前面我們討論了關於執行緒池的實現原理，這一節我們來看一下它的具體使用： public class Test { public static void main(String[] args) { ThreadPoolExe

執行緒池 一、executor介面和ExecutorService介面介紹

工作這麼多年，很少有時間寫部落格，昨天和一個正在跳槽找工作的同學交流，他是做web的，面試的時候被問到了執行緒池一塊的技術，被難住了！這讓我不禁也想鞏固下我這方便的基礎了，天天在用的東西，尤其是像我們這種做網際網路服務端開發的，高併發處理中建立一個優異Thread Pool對

執行緒池工作機制與原理

書接上文，Java執行緒池。 接下來記錄一下執行緒池的工作機制和原理 執行緒池的兩個核心佇列： 執行緒等待池，即執行緒佇列BlockingQueue。任務處理池（PoolWorker），即正在工作的Thread列表（HashSet<Worker>）。 執行緒

JAVA執行緒池（ThreadPoolExecutor）原理分析與使用

在我們的開發中，“池”的概念並不罕見，有資料庫連線池、執行緒池、物件池、常量池等。下面我們主要針對執行緒池來一步一步揭開執行緒池的面紗。 使用執行緒池的好處 （1）降低資源消耗 可以重複利用自己建立的執行緒降低執行緒建立和銷燬造成的消耗。 （2）提高響應速度 當任務到達時

Java併發（4）深入分析java執行緒池框架及實現原理（一）

先說說我個人對執行緒池的理解：執行緒池顧名思義是一個裝有很多執行緒的池子，這個池子維護著從執行緒建立到銷燬的怎個生命週期以及執行緒的分配，使用者只需要把任務提交給這個執行緒池而不用去關心執行緒池如何建立執行緒，執行緒池會自己給這些任務分配執行緒資源來完成任務。 java的E

執行緒以及執行緒池的幾種方式和優缺點

問：執行緒池常用的幾種型別？答：Java通過Executors提供四種執行緒池，分別為：１　newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。Executors.newCachedThr

執行緒池中使用條件變數和訊號量的效能比較

面試的時候經常被問到互斥量，條件變數和訊號量之間的問題。比如前幾天華為面試就被問到互斥量和訊號量的區別，說到互斥量也可以使用一個二值訊號量來實現，什麼情況是隻能使用互斥量而不能使用訊號量的。這個問題當時我只回答出一種情況，想了解詳情的可自行百度。如面試官所說，訊

執行緒池的優點及其原理

一 使用執行緒池的好處 池化技術應用：執行緒池、資料庫連線池、http連線池等等。 池化技術的思想主要是為了減少每次獲取資源的消耗，提高對資源的利用率。 執行緒池提供了一種限制、管理資源的策略。 每個執行緒池還維護一些基本統計資訊，例如已完成任務的數量。 使用執行緒池的好處： 降低資源消耗：通過重複利

硬核乾貨：4W字從原始碼上分析JUC執行緒池ThreadPoolExecutor的實現原理

![](https://throwable-blog-1256189093.cos.ap-guangzhou.myqcloud.com/202008/j-u-c-t-p-e-logo.png) ## 前提 很早之前就打算看一次JUC執行緒池`ThreadPoolExecutor`的原始碼實現，由於近段時間

執行緒池原理–拒絕策略之RejectedExecutionHandler類

文章目錄 執行緒池原理–拒絕策略之RejectedExecutionHandler類 RejectedExecutionHandler 介面 CallerRunsPolicy AbortPolicy Disca

執行緒池的RejectedExecutionHandler（拒絕策略）

JAVA為多執行緒場景提供了執行緒池，下面是一個執行緒池的構造方法： public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,

JDK執行緒池的拒絕策略

關於新疆服務請求未帶入來話原因的問題        經核查，該問題是由於立單介面內部沒有成功呼叫接續的 “更新來電原因介面”導致的，接續測更新來電原因介面編碼：NGCCT_UPDATESRFLAG_PUT ，立單介面呼叫程式碼如下： fin

Dubbo裡面執行緒池的拒絕策略

Dubbo裡面執行緒池的拒絕策略 public class AbortPolicyWithReport extends ThreadPoolExecutor.AbortPolicy { protected static final Logger logger = LoggerFactory.get

關於執行緒池工作原理，任務拒接策略有哪幾種

　在ThreadPoolExecutor類中提供了四個構造方法： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class ThreadPoolExecutor extends