多线程：线程池的拒绝策略

原創 zhaoliubao1 2020-06-22 23:31

当线程池中的资源全部被占用时，对于新添加的runnable有不同的处理策略，默认情况下有如下四种拒绝策略：
    RejectedExecutionHandler rejected = null;
    rejected = new ThreadPoolExecutor.AbortPolicy();//默认，队列满了丢任务抛出异常
    rejected = new ThreadPoolExecutor.DiscardPolicy();//队列满了丢任务不异常
    rejected = new ThreadPoolExecutor.DiscardOldestPolicy();//将最早进入队列的任务删，之后再尝试加入队列
    rejected = new ThreadPoolExecutor.CallerRunsPolicy();//如果添加到线程池失败，那么主线程会自己去执行该任务

参考文献：https://www.cnblogs.com/muxi0407/p/11811669.html

 

1.AbortPolicy策略：当任务添加到线程池被拒绝时抛出异常（其中被拒绝分为workQueue满了或者调用shutdown（）方法）该拒绝策略为线程池的默认拒绝策略。

a.workQueue被用完 

package com.springboot.thread;

import java.util.concurrent.*;

public class AbortPolicyTest {

    public static void main(String[] args) {
        //ArrayBlockingQueue linked = new ArrayBlockingQueue(2);
        LinkedBlockingQueue linked  = new LinkedBlockingQueue(2);
        //LinkedBlockingDeque linked  = new LinkedBlockingDeque(2);
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,3,1L, TimeUnit.SECONDS,linked,new ThreadPoolExecutor.AbortPolicy());
        AbortPolicyRunnable runnable = new AbortPolicyRunnable();
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
    }
}

class AbortPolicyRunnable implements Runnable{
    @Override
    public void run() {
        try {
            //System.out.println("began : current thread is :"+ Thread.currentThread().getName());
            Thread.sleep(1000);
            System.out.println("end : current thread is :"+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.springboot.thread.AbortPolicyRunnable@58372a00 rejected from java.util.concurrent.ThreadPoolExecutor@4dd8dc3[Running, pool size = 3, active threads = 3, queued tasks = 2, 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 com.springboot.thread.AbortPolicyTest.main(AbortPolicyTest.java:18)
end : current thread is :pool-1-thread-1
end : current thread is :pool-1-thread-3
end : current thread is :pool-1-thread-2
end : current thread is :pool-1-thread-1
end : current thread is :pool-1-thread-3

b.使用shutdown（）方法

package com.springboot.thread;

import java.util.concurrent.*;

public class AbortPolicyTest {

    public static void main(String[] args) {
        //ArrayBlockingQueue linked = new ArrayBlockingQueue(2);
        LinkedBlockingQueue linked  = new LinkedBlockingQueue(2);
        //LinkedBlockingDeque linked  = new LinkedBlockingDeque(2);
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,3,1L, TimeUnit.SECONDS,linked,new ThreadPoolExecutor.AbortPolicy());
        AbortPolicyRunnable runnable = new AbortPolicyRunnable();
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.shutdown();
        threadPoolExecutor.execute(runnable);
        /*threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);*/
    }
}

class AbortPolicyRunnable implements Runnable{
    @Override
    public void run() {
        try {
            //System.out.println("began : current thread is :"+ Thread.currentThread().getName());
            Thread.sleep(1000);
            System.out.println("end : current thread is :"+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.springboot.thread.AbortPolicyRunnable@3b9a45b3 rejected from java.util.concurrent.ThreadPoolExecutor@7699a589[Shutting down, pool size = 1, active threads = 1, queued tasks = 0, 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 com.springboot.thread.AbortPolicyTest.main(AbortPolicyTest.java:15)
end : current thread is :pool-1-thread-1

c.从如下源码代码可以看出AbortPolicy为线程的默认拒绝策略

private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();


public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

2.DiscardPolicy:当任务添加到线程池中被拒绝时，直接丢弃被拒接的任务，不抛出异常。

package com.springboot.thread;

import java.util.concurrent.*;

public class AbortPolicyTest {

    public static void main(String[] args) {
        //ArrayBlockingQueue linked = new ArrayBlockingQueue(2);
        //LinkedBlockingQueue linked  = new LinkedBlockingQueue(2);
        //LinkedBlockingDeque linked  = new LinkedBlockingDeque(2);
        SynchronousQueue linked = new SynchronousQueue();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,3,1L, TimeUnit.SECONDS,linked,new ThreadPoolExecutor.DiscardPolicy());
        AbortPolicyRunnable runnable = new AbortPolicyRunnable();
        threadPoolExecutor.execute(runnable);
        //threadPoolExecutor.shutdown();
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
    }
}

class AbortPolicyRunnable implements Runnable{
    @Override
    public void run() {
        try {
            //System.out.println("began : current thread is :"+ Thread.currentThread().getName());
            Thread.sleep(1000);
            System.out.println("end : current thread is :"+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

end : current thread is :pool-1-thread-2
end : current thread is :pool-1-thread-3
end : current thread is :pool-1-thread-1

3.DiscardOldestPolicy策略：当任务添加到线程池中被拒绝时，线程池会放弃等待队列中最旧未处理的任务，然后将被拒绝的任务添加到等待队列中。

（1）.不使用SynchronousQueue

package com.springboot.thread;

import java.util.concurrent.*;

public class AbortPolicyTest {

    public static void main(String[] args) {
        //ArrayBlockingQueue linked = new ArrayBlockingQueue(2);
        //LinkedBlockingQueue linked  = new LinkedBlockingQueue(2);
        LinkedBlockingDeque linked  = new LinkedBlockingDeque(2);
        //SynchronousQueue linked = new SynchronousQueue();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,3,1L, TimeUnit.SECONDS,linked,new ThreadPoolExecutor.DiscardOldestPolicy());
        AbortPolicyRunnable runnable = new AbortPolicyRunnable();
        threadPoolExecutor.execute(runnable);
        //threadPoolExecutor.shutdown();
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
    }
}

class AbortPolicyRunnable implements Runnable{
    @Override
    public void run() {
        try {
            //System.out.println("began : current thread is :"+ Thread.currentThread().getName());
            Thread.sleep(1000);
            System.out.println("end : current thread is :"+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

 运行结果：

end : current thread is :pool-1-thread-3
end : current thread is :pool-1-thread-2
end : current thread is :pool-1-thread-1
end : current thread is :pool-1-thread-3
end : current thread is :pool-1-thread-2

（2）.使用 SynchronousQueue

package com.springboot.thread;

import java.util.concurrent.*;

public class AbortPolicyTest {

    public static void main(String[] args) {
        //ArrayBlockingQueue linked = new ArrayBlockingQueue(2);
        //LinkedBlockingQueue linked  = new LinkedBlockingQueue(2);
        //LinkedBlockingDeque linked  = new LinkedBlockingDeque(2);
        SynchronousQueue linked = new SynchronousQueue();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,3,1L, TimeUnit.SECONDS,linked,new ThreadPoolExecutor.DiscardOldestPolicy());
        AbortPolicyRunnable runnable = new AbortPolicyRunnable();
        threadPoolExecutor.execute(runnable);
        //threadPoolExecutor.shutdown();
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
    }
}

class AbortPolicyRunnable implements Runnable{
    @Override
    public void run() {
        try {
            //System.out.println("began : current thread is :"+ Thread.currentThread().getName());
            Thread.sleep(1000);
            System.out.println("end : current thread is :"+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

Exception in thread "main" java.lang.StackOverflowError
	at java.util.concurrent.SynchronousQueue.offer(SynchronousQueue.java:912)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1361)
	at ......
end : current thread is :pool-1-thread-2
end : current thread is :pool-1-thread-3

 当使用同步无缓存队列时，当我们的runnable大于线程池的的最大线程数并使用忽略最旧未执行任务时会报栈溢出的异常。

4.CallerRunsPolicy策略：

如下截图来自于《java并发编程：核心方法与核心框架》

但是本人觉得书中的描述有错误，并不是调用线程池的Thread对象来处理被拒绝的任务，而是谁让线程池去处理任务那么被拒绝的任务就由谁来处理。就比如你的上司给你分配任务，你下面又有几个小弟，但是只负责分配任务并不做任务，他分配任务的时候给你说了句“把任务分给兄弟没，如果兄弟们没做不完的话把 多余的任务给我做。”

package com.springboot.thread;

import java.util.concurrent.*;

public class AbortPolicyTest {

    public static void main(String[] args) {
        //ArrayBlockingQueue linked = new ArrayBlockingQueue(2);
        //LinkedBlockingQueue linked  = new LinkedBlockingQueue(2);
        LinkedBlockingDeque linked  = new LinkedBlockingDeque(2);
        //SynchronousQueue linked = new SynchronousQueue();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,3,1L, TimeUnit.SECONDS,linked,new ThreadPoolExecutor.CallerRunsPolicy());
        AbortPolicyRunnable runnable = new AbortPolicyRunnable();
        threadPoolExecutor.execute(runnable);
        //threadPoolExecutor.shutdown();
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
        threadPoolExecutor.execute(runnable);
    }
}

class AbortPolicyRunnable implements Runnable{
    @Override
    public void run() {
        try {
            //System.out.println("began : current thread is :"+ Thread.currentThread().getName());
            Thread.sleep(1000);
            System.out.println("end : current thread is :"+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

end : current thread is :pool-1-thread-1
end : current thread is :main
end : current thread is :pool-1-thread-3
end : current thread is :pool-1-thread-2
end : current thread is :pool-1-thread-1
end : current thread is :pool-1-thread-3

从运行结果我们可以看到，main线程叫线程池去干活，然后多余的任务就自己干了。

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

在一个多线程系统中，主进程应该写什么？

在一個多線程的系統中，主線程應該不佔資源，而且不應該結束。 遵循此原則，在c++的系統中，用c++11的代碼實現在主線程中等待主線程被喚醒，且不結束。 #include <condition_variable> #include <mut

懵圈丰 2020-07-05 01:09:04

Java并发与多线程-详解线程池

Java併發與多線程-詳解線程池 什麼是線程池？ 在此，我們參考一下百科的定義： 線程池（英語：thread pool）：一種線程使用模式。線程過多會帶來調度開銷，進而影響緩存局部性和整體性能。而線程池維護着多個線程，等待着監督

快乐柠檬 2020-07-07 20:23:31

Spring @Async注解

1.@Async註解使用條件 @Async源碼@Async註解一般用在類的方法上，如果用在類上，那麼這個類所有的方法都是異步執行的； 所使用的@Async註解方法的類對象應該是Spring容器管理的bean對象； 調用異步方法類上需要配置

zl1zl2zl3 2020-07-07 15:46:29

JAVA思维导图系列：多线程中级

多線程中級，包含控制線程的幾種方法、線程的同步、線程組，有返回值的線程、線程之前的通信、線程池和線程的幾個相關類 線程同步 當多個線程訪問同一資源時，加synchronized對資源進行加鎖 synchronized可以修飾代

hacke2 2020-07-07 05:13:19

java基础篇--详解 ThreadPoolExecutor 的参数含义及源码执行流程？

線程池是爲了避免線程頻繁的創建和銷燬帶來的性能消耗，而建立的一種池化技術，它是把已創建的線程放入“池”中，當有任務來臨時就可以重用已有的線程，無需等待創建的過程，這樣就可以有效提高程序的響應速度。但如果要說線程池的話一定離不開 Threa

爱分享的淘金达人 2020-07-06 23:59:57

Android-Universal-Image-Loader 图片异步加载类库的使用（超详细配置）提供Android studio 的DEMO

       這個圖片異步加載並緩存的類已經被很多開發者所使用，是最常用的幾個開源庫之一，主流的應用，隨便反編譯幾個火的項目，都可以見到它的身影。        可是有的人並不知道如何去使用這庫如何進行配置，網上查到的信息對於剛接觸的

孝诚 2020-07-06 23:24:19

JDK自带线程池解析

原文：http://blog.csdn.net/whuqin/article/details/6578477 JDK1.5以後提供了使用線程池的方法，相關類放在java.util.concurrent，java.util.concur

kevin_li0719 2020-07-06 04:38:02

Android中的线程池简介

Android中的線程池 線程池有以下三個優點： （1）重用線程池中的線程，避免因爲線程的創建和銷燬所帶來的性能開銷。 （2）能有效控制線程的最大併發數，避免大量的線程之間的相互搶佔資源而導致的阻塞現象。 （3）能夠對線程進行

我的小侯子 2020-07-05 18:28:23

定时器ScheduledExecutor的使用

定時器，就是我們平常所說的定時器。簡單定義，就是在固定的時間內，它會自動切換到下一個動作。那麼，在Java中，我們應該怎麼去應用呢？如何創建對象，創建對象後，又如何去實現相應的動作呢？下面我們以一個簡單的例子說明: 例:創建一個定時器，在

huangxuanheng 2020-07-05 13:54:52

线程并发库_线程池

線程池 六、線程池    前言：在以前創建一個線程時，總是要手動創建一個線程，然後啓動運行；並且一旦線程運行結束後，就作廢；當要運行的線程數過多時，這種創建方式的弊端便會很明顯。就好比一個公司接待客戶，當每個客戶需要服務時，就去招聘一個

johnnywuliq 2020-07-05 08:39:39

面试项目_交通灯管理系统

交通燈管理系統 一、需求     模擬實現十字路口的交通燈管理系統邏輯，具體需求如下：     1、異步隨機生成按照各個路線行駛的車輛：     例如：         由南向而來去往北向的車輛 ---- 直行車輛；         由西

johnnywuliq 2020-07-05 08:39:39

JUC线程池--线程池架构

線程池的架構圖如下： Executor 它是”執行者”接口，它是來執行任務的。準確的說，Executor提供了execute()接口來執行已提交的 Runnable 任務的對象。Executor存在的目的是提供一種將”任務提

Hey_WonderfulWorld 2020-07-05 08:03:43

java使用局部线程池导致的泄露问题

局部線程池使用不當會導致OutOfMemoryError。 內存泄露的代碼： public class JVMDemoTest { public static void main(String[] args) throws Excep

erdongritian 2020-07-05 03:37:19

什么是线程池——第一篇

Java中的線程池是運用場景最多的併發框架，幾乎所有需要異步或併發執行任務的程序都可以使用線程池。 線程池的三個好處： 降低資源消耗。通過重複利用已創建的線程降低線程創建和銷燬造成的消耗。 提高響應速度。當任務到達時，任務

//Nevada 2020-07-04 14:03:15

java 线程池简述 Executor

java 線程池 Executor 體系概要UMLExecutor 執行器ExecutorServiceExecutors 工具類ThreadFactory 線程工廠 資料來源於 JDK 1.8 API UML Execut

程序猿-Jojo 2020-07-04 03:41:50