ThreadPoolExecutor 四种策略

最新推荐文章于 2024-08-02 09:30:37 发布
最新推荐文章于 2024-08-02 09:30:37 发布
阅读量677 收藏 2
点赞数
文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38362455/article/details/86567654
版权
  1. AbortPolicy: 拒绝策略,不指定为默认值
  2. CallerRunsPolicy: 在任务被拒绝添加后，会调用当前线程池的所在的线程去执行被拒绝的任务
  3. DiscardPolicy: 放弃策略,线程池拒绝的任务直接抛弃，不会抛异常也不会执行
  4. DiscardOldestPolicy: 任务被拒绝添加时，会抛弃任务队列中最旧的任务也就是最先加入队列的，再把这个新任务添加进去。

AbortPolicy(拒绝策略)为默认值

源码：可以看到直接抛出运行异常

public static class AbortPolicy implements RejectedExecutionHandler {
        /**
         * Creates an {@code AbortPolicy}.
         */
        public AbortPolicy() { }

        /**
         * Always throws RejectedExecutionException.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         * @throws RejectedExecutionException always
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }

测试代码：

public class Test {

	public static void main(String[] args) {

		ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 2, 0
				,TimeUnit.MICROSECONDS
				,new ArrayBlockingQueue<>(2,true)
				,new ThreadPoolExecutor.AbortPolicy());  // 拒绝策略

		for (int i = 1; i <= 10; i++) {
			System.out.println("添加第"+i+"个线程");
			executor.execute(new MyThread("线程"+i));
			Iterator iterator = executor.getQueue().iterator();
			if (iterator.hasNext()) {
				while (iterator.hasNext()) {
					MyThread thread = (MyThread) iterator.next();
					System.out.println("队列queue中：" + thread.name);
				}
			}else {
				System.out.println("队列中为null");
			}
		}
	}

	// 内部类 主要是为线程起名称方便观察
	static class MyThread implements Runnable {
		String name;
		public MyThread(String name) {
			this.name = name;
		}
		@Override
		public void run() {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("线程:" + Thread.currentThread().getName() + " 执行:" + name + "  run");
		}
	}
}

运行结果乳如下：

添加第1个线程
队列中为null
添加第2个线程
队列queue中：线程2
添加第3个线程
队列queue中：线程2
队列queue中：线程3
添加第4个线程
队列queue中：线程2
队列queue中：线程3
添加第5个线程
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task Test$MyThread@593634ad rejected from java.util.concurrent.ThreadPoolExecutor@20fa23c1[Running, pool size = 2, active threads = 2, queued tasks = 2, 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 Test.main(Test.java:33)
线程:pool-1-thread-2 执行:线程4  run
线程:pool-1-thread-1 执行:线程1  run
线程:pool-1-thread-1 执行:线程3  run
线程:pool-1-thread-2 执行:线程2  run

分析运行结果：

1.添加第一个任务时,直接执行
  此时队列中:null
2.添加第二个任务时,由于线程核心数为"1"并且核心线程被占用,所以被加入到队列中
  此时队列中:任务二
3.添加第三个任务时同上
  此时队列中:任务二、任务三
4.添加第四个任务时,因为核心任务还在运行,而且任务队列已经满了,所以直接创建新线程执行第四个任务
  此时队列中:任务二、任务三
5.添加第五个任务时,因为 maxPoolSize为2 + 队列BlockingQueue容量为2 = 4 也就是最大承载为4个线程所以执行拒绝策略的rejectedExecution方法,这里就是执行AbortPolicy的rejectedExecution方法直接抛出异常
6.最终,只有四个线程能完成运行。后面的都被拒绝了。

CallerRunsPolicy

源码：当发生拒绝是，调用当前线程池的所在的线程去执行被拒绝的任务

public static class CallerRunsPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code CallerRunsPolicy}.
         */
        public CallerRunsPolicy() { }

        /**
         * Executes task r in the caller's thread, unless the executor
         * has been shut down, in which case the task is discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }

测试代码：其它同上

ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 2, 0
				,TimeUnit.MICROSECONDS
				,new ArrayBlockingQueue<>(2,true)
				,new ThreadPoolExecutor.AbortPolicy());  // 在任务被拒绝添加后，会调用当前线程池的所在的线程去执行被拒绝的任务

运行结果：

添加第1个线程
队列中为null
添加第2个线程
队列queue中：线程2
添加第3个线程
队列queue中：线程2
队列queue中：线程3
添加第4个线程
队列queue中：线程2
队列queue中：线程3
添加第5个线程
线程:main 执行:线程5  run
队列queue中：线程2
队列queue中：线程3
添加第6个线程
线程:pool-1-thread-2 执行:线程4  run
线程:pool-1-thread-1 执行:线程1  run
线程:pool-1-thread-1 执行:线程3  run
线程:main 执行:线程6  run
队列中为null
添加第7个线程
线程:pool-1-thread-2 执行:线程2  run
队列queue中：线程7
添加第8个线程
队列queue中：线程8
添加第9个线程
队列queue中：线程8
队列queue中：线程9
添加第10个线程
队列queue中：线程8
队列queue中：线程9
线程:pool-1-thread-2 执行:线程7  run
线程:pool-1-thread-3 执行:线程10  run
线程:pool-1-thread-2 执行:线程8  run
线程:pool-1-thread-3 执行:线程9  run

分析结果：

添加第五个任务,任务5的时候,同样被线程池拒绝了,因此执行了CallerRunsPolicy的rejectedExecution方法,
这个方法直接执行任务的run方法.因此可以看到任务5是在main线程中执行的
这个策略的缺点就是可能会阻塞主线程。

DiscardPolicy(放弃策略)

源码：被线程池拒绝的任务直接抛弃，不会抛异常也不会执行。

public static class DiscardPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardPolicy}.
         */
        public DiscardPolicy() { }

        /**
         * Does nothing, which has the effect of discarding task r.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }

测试代码：其它同上

ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 2, 0
				,TimeUnit.MICROSECONDS
				,new ArrayBlockingQueue<>(2,true)
				,new ThreadPoolExecutor.DiscardPolicy());
//线程池拒绝的任务直接抛弃，不会抛异常也不会执行。

运行结果：

添加第1个线程
队列中为null
添加第2个线程
队列queue中：线程2
添加第3个线程
队列queue中：线程2
队列queue中：线程3
添加第4个线程
队列queue中：线程2
队列queue中：线程3
添加第5个线程
队列queue中：线程2
队列queue中：线程3
添加第6个线程
队列queue中：线程2
队列queue中：线程3
添加第7个线程
队列queue中：线程2
队列queue中：线程3
添加第8个线程
队列queue中：线程2
队列queue中：线程3
添加第9个线程
队列queue中：线程2
队列queue中：线程3
添加第10个线程
队列queue中：线程2
队列queue中：线程3
线程:pool-1-thread-1 执行:线程1  run
线程:pool-1-thread-2 执行:线程4  run
线程:pool-1-thread-1 执行:线程2  run
线程:pool-1-thread-2 执行:线程3  run

分析结果：

只有四个任务被执行了,其他什么反应都没有,直接丢弃。

DiscardOldestPolicy(放弃最早策略)

源码：在rejectedExecution先从任务队列总弹出最先加入的任务，空出一个位置，然后再次执行execute方法把任务加入队列。

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardOldestPolicy} for the given executor.
         */
        public DiscardOldestPolicy() { }

        /**
         * Obtains and ignores the next task that the executor
         * would otherwise execute, if one is immediately available,
         * and then retries execution of task r, unless the executor
         * is shut down, in which case task r is instead discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }

测试代码：其它同上

ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 2, 0
				,TimeUnit.MICROSECONDS
				,new ArrayBlockingQueue<>(2,true)
				,new ThreadPoolExecutor.DiscardOldestPolicy());

运行结果：

添加第1个线程
队列中为null
添加第2个线程
队列queue中：线程2
添加第3个线程
队列queue中：线程2
队列queue中：线程3
添加第4个线程
队列queue中：线程2
队列queue中：线程3
添加第5个线程
队列queue中：线程3
队列queue中：线程5
添加第6个线程
队列queue中：线程5
队列queue中：线程6
添加第7个线程
队列queue中：线程6
队列queue中：线程7
添加第8个线程
队列queue中：线程7
队列queue中：线程8
添加第9个线程
队列queue中：线程8
队列queue中：线程9
添加第10个线程
队列queue中：线程9
队列queue中：线程10
线程:pool-1-thread-2 执行:线程4  run
线程:pool-1-thread-1 执行:线程1  run
线程:pool-1-thread-2 执行:线程10  run
线程:pool-1-thread-1 执行:线程9  run

分析结果：

可以看到线程9和线程10顶替了线程2和线程3的位子,其他线程被放弃,既不运行也不抛异常
小贼驴
关注
Java并发编程系列27:ThreadPoolExecutor的4种拒绝策略
fen_fen的专栏
02-13 8207
ThreadPoolExecutor拒绝策略
ThreadPoolExecutor的四种抛弃策略
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
11-06 2090
常规情况下： ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 3, 1, TimeUnit.SECONDS, new LinkedBlockingQueue&lt;Runnable&gt;(5), new ThreadPoolExecutor.AbortPolicy()); //任务8,...
ThreadPoolExecutor——高效处理并发任务的必备良器
xindoo
05-01 2763
ThreadPoolExecutor是Java中用于管理线程池的一个类，它能够创建和管理线程池，以提高应用程序的性能和可靠性。它具有灵活的线程池管理、高效的任务处理和可靠的异常处理等特点。尤其适用于任务量大、执行时间长、任务类型多样的应用场景，例如Web服务器、数据库连接池、文件处理等。通过合理地设置线程池参数、处理任务和异常、监控和调优线程池，可以提高应用程序的性能和可靠性，避免任务丢失或线程池崩溃的问题。
Linux下如何安装配置Memcached缓存服务器
最新发布
小筱在线博客
08-02 487
总结： 通过以上步骤，可以在Linux系统中安装和配置Memcached缓存服务器，并使用相应的Memcached客户端来操作Memcached服务器。在配置Memcached时，可以根据实际需求设置监听的IP地址、端口号、分配的内存大小、最大连接数等参数。在Linux系统下，安装和配置Memcached缓存服务器相对简单，本文将介绍如何在Linux系统中安装和配置Memcached。根据自己选择的编程语言，安装相应的Memcached客户端库，并根据其文档进行使用。
ThreadPoolExecutor策略配置以及应用场景
weixin_33777877的博客
02-12 205
2019独角兽企业重金招聘Python工程师标准>>> ...
线程池的处理策略(ThreadPoolExecutor)
龙旋的博客
12-13 1846
1.什么是线程池？ 由于线程的运行的速度太快，可能线程的销毁时间比运行的时间还要长，所以出现线程池可以在池里面先定义一定数量的线程，等要用的时候再从线程池里面进行获取，用完之后再统一进行销毁。 2.线程池的处理策略 图解析： 1.先在线程池里面定义5个核心线程，当有任务来的时候，会由核心线程进行处理任务。 2.再有任务来的时候，此时核心线程正在处理任务，所以会将来的任务放在消息队列（阻塞队列）中...
java线程池_面试官问：讲讲Java线程池的8大拒绝策略？
weixin_39796868的博客
11-17 184
点击上方“linkoffer”，选择关注公众号高薪职位第一时间送达作者：陈凯玲来源：https://urlify.cn/6Z322u谈到java的线程池最熟悉的莫过于ExecutorService接口了，jdk1.5新增的java.util.concurrent包下的这个api，大大的简化了多线程代码的开发。而不论你用FixedThreadPool还是CachedThreadPool其背...
ThreadPoolExecutor浅谈
weixin_34234823的博客
06-11 133
耐心看完的你或多或少会有收获！ ThreadPoolExecutor field 的解释 在了解线程池之前，希望你已了解了 Java 内存模型 和 AQS CAS /** * The runState provides the main lifecycle control, taking on values: * * RUNNING: Acc...
Java并发编程系列28:ThreadPoolExecutor自定义拒绝策略(1)
fen_fen的专栏
02-13 444
ThreadPoolExecutor自定义策略(1) 首先说下ThreadPoolExecutor的四种拒绝策略 ThreadPoolExecutor.AbortPolicy ThreadPoolExecutor 默认策略 直接抛出java.util.concurrent.RejectedExecutionException异常 ThreadPoolExecutor.DiscardPolicy 丢弃当前任务，但是不抛出异常
ThreadPoolExecutor使用DiscardPolicy策略时注意
小z的博客
06-15 5249
#ThreadPoolExecutor使用注意 偶然发现一个使用ThreadPoolExecutor潜在的风险 如果设置corePoolSize，maximumPoolSize以及queue大小过小，并且设置的DiscardPolicy，并且配合有返回的Future时有可能会出现无限阻塞，如下代码所示： public static void main(String[] args) { ThreadPoolExecutor threadPoolExecutor = new ThreadPool
线程池ThreadPoolExecutor的使用及拒绝策略
Rain_Butter_fly的博客
07-28 448
文章目录一、ThreadPoolExecutor介绍 1. 为什么要用线程池？ 2. ThreadPoolExecutor构造函数四个核心参数 3. 创建线程池实例二、如何使用线程池 1.创建线程 2.创建线程池，并将线程加入线程池三、线程数量超过maximumPoolSize时的四种拒绝策略 1. AbortPolicy(默认策略)结果 2. DiscardPolicy 3. DiscardOldestPolicy 4. CallerRunsPolicy总结 一、ThreadPoolExecutor介
线程池的四大拒绝策略
一名编程小白的Java学习日志
03-24 1983
线程池的四大拒绝策略
ThreadPoolExecutor 饱和策略
weixin_43312993的博客
05-08 388
对于ThreadPoolExecutor 饱和策略的解释可以参考以下文章：https://blog.csdn.net/w605283073/article/details/89930154
Java 线程池ThreadPoolExecutor
热门推荐
abing37的专栏
09-01 2万+
 Java线程池ThreadPoolExecutor. JDK1.5开始关于多线程加了很多特性。如：ConcurrentHashMap:放弃使用公用锁同步每一个方法，使用了更细化的锁机制，分离锁。对于大数据量的HashMap同步操作效率有了较大提升。CopyOnWriteArrayList:是同步Lis
Java线程池ThreadPoolExecutor详解（一篇就够了）
好好学java
05-03 4908
Executor框架主要由三部分组成，任务任务的执行者执行结果，ThreadPoolExecutor和ScheduledThreadPoolExecutor的设计思想也是将这三个关键要素进行了解耦，将任务的提交和执行分离。任务在和中任务是指实现了Runnable接口和Callable接口的类，中将任务转换成FutureTask类，中任务被转换成类，该类继承FutureTask，并重写了run方法，实现了延时执行任务和周期性执行任务。任务的执行者包括任务执行机制的核心接口Executor，以及继承自。
ThreadPoolExecutor任务调度策略
阿振的博客
02-01 575
execute：  execute方法时暴露给开发者提交任务的方法，这个方法就是整个线程池的入口。当然还有submit类方法，实际上也是调用了execute方法。 public void execute(Runnable command) { if (command == null) throw new NullPointerException(); i
【十二】Java设计模式GOF23之策略模式（ThreadPoolExecutor类的拒绝策略源码）
Sid小杰的博客
01-16 435
简介 在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。 在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。 策略模式的角色和职责 1.Strategy:策略（算法）抽象 2.ConcreteStrategy:各种策略（算法...
ThreadPoolExecutor 的拒绝策略
WaaTong的博客
01-25 1016
ThreadPoolExecutor在任务提交时可能会遇到线程池已经饱和的情况，即所有的核心线程和队列都已经被占用，而且线程池不能再创建新的线程来执行任务。在这种情况下，ThreadPoolExecutor 会采用预定义的拒绝策略来处理这些无法执行的任务。
浅析ThreadPoolExecutor
张小菜在路上
08-12 612
从Java5开始，Java提供了自己的线程池。线程池就是一个线程的容器，每次只执行额定数量的线程。ThreadPoolExecutor就是这样的线程池。 ThreadPoolExecutor有多个构造函数，以下以最简单的为例 /** * Creates a new {@code ThreadPoolExecutor} with the given initial * par
ThreadPoolExecutor拒绝策略
08-21
ThreadPoolExecutor拒绝策略是指当线程池无法接受新的任务时，如何处理这些被拒绝的任务。ThreadPoolExecutor提供了几种不同的拒绝策略。其中，DiscardPolicy是一种拒绝策略，它会直接丢弃当前的任务，而不会抛出异常。 另一种拒绝策略是CallerRunsPolicy，它会由调用线程（也就是提交任务的线程）来处理该任务。当任务被拒绝时，如果线程池没有关闭，调用线程会执行该任务。 举个例子，如果我们创建了一个ThreadPoolExecutor对象并指定了DiscardPolicy作为拒绝策略，当线程池中的线程数达到最大值并且阻塞队列也已满时，新的任务将被直接丢弃。 总之，ThreadPoolExecutor的拒绝策略决定了当线程池无法接受新任务时的处理方式，可以根据具体需求选择合适的拒绝策略来处理被拒绝的任务。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [Java并发编程系列27:ThreadPoolExecutor的4种拒绝策略](https://blog.csdn.net/fen_fen/article/details/122909142)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值