线程池的四种拒绝策略实践

原创 已于 2023-07-15 09:58:13 修改 · 375 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

于 2023-07-15 09:55:34 首次发布

1 ThreadPoolExecutor.AbortPolicy

抛出 RejectedExecutionException来拒绝新任务的处理

//第一种拒绝策略
    //最大核心线程 1
    //最大线程 2
    //队列长度 1
    private static ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1,2,10, TimeUnit.SECONDS,new ArrayBlockingQueue<>(1));

    public static void main(String[] args) throws InterruptedException {
        //一共放置四个线程

        //第一个线程交给核心线程执行
        threadPool.execute(()->{
            System.out.println("第一任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        //因为核心线程到达最大值，第二个线程放进任务队列
        threadPool.execute(()->{
            System.out.println("第二任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        //因为核心线程已满，任务队列已满，第三个线程交给新开的普通线程
        threadPool.execute(()->{
            System.out.println("第三任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        //因为核心线程已满，任务队列已满，总线程数已满，执行拒绝策略，不去执行第四个任务，并抛出RejectedExecutionException异常
        threadPool.execute(()->{
            System.out.println("第四任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });


        Thread.sleep(100000);

        System.out.println("全部任务执行");
    }

Connected to the target VM, address: '127.0.0.1:57394', transport: 'socket'
第一任务开始执行
第三任务开始执行
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task test.ThreadTest.ThreadPool.RejectedExecution$$Lambda$4/716143810@1888ff2c rejected from java.util.concurrent.ThreadPoolExecutor@6adca536[Running, pool size = 2, active threads = 2, 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 test.ThreadTest.ThreadPool.RejectedExecution.main(RejectedExecution.java:55)
第二任务开始执行

2 ThreadPoolExecutor.CallerRunsPolicy

多出来任务的先让main线程帮忙处理，main线程在处理期间提交的任务会阻塞在任务队列外

//第二种拒绝策略，可以扩展
    //最大核心线程 1
    //最大线程 2
    //队列长度 1
    private static ThreadPoolExecutor threadPool1 = new ThreadPoolExecutor(1,2,10, TimeUnit.SECONDS,new ArrayBlockingQueue<>(1),new ThreadPoolExecutor.CallerRunsPolicy());


    public static void main(String[] args) throws InterruptedException {
        //一共放置四个线程

        //第一个线程交给核心线程执行
        threadPool1.execute(()->{
            System.out.println(Thread.currentThread().getName()+"第一任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        //因为核心线程到达最大值，第二个线程放进任务队列
        threadPool1.execute(()->{
            System.out.println(Thread.currentThread().getName()+"第二任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        //因为核心线程已满，任务队列已满，第三个线程交给新开的普通线程
        threadPool1.execute(()->{
            System.out.println(Thread.currentThread().getName()+"第三任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        //因为核心线程已满，任务队列已满，总线程数已满，执行拒绝策略，使用主线程main执行
        threadPool1.execute(()->{
            System.out.println(Thread.currentThread().getName()+"第四任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        //我们不知道 第五条干啥去了 初步推测在队列外等着，直到第二任务被拿出，第五任务放入队列
        threadPool1.execute(()->{
            System.out.println(Thread.currentThread().getName()+"第五任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });



        Thread.sleep(100000);

        System.out.println("全部任务执行");
    }

Connected to the target VM, address: '127.0.0.1:57525', transport: 'socket'
pool-2-thread-1第一任务开始执行
pool-2-thread-2第三任务开始执行
main第四任务开始执行
pool-2-thread-1第二任务开始执行
pool-2-thread-2第五任务开始执行

3 ThreadPoolExecutor.DiscardPolicy

直接丢弃

  //第三种拒绝策略，直接抛弃掉
    //最大核心线程 1
    //最大线程 2
    //队列长度 1
    private static ThreadPoolExecutor threadPool2 = new ThreadPoolExecutor(1,2,10, TimeUnit.SECONDS,new ArrayBlockingQueue<>(1),new ThreadPoolExecutor.DiscardPolicy());


    public static void main(String[] args) throws InterruptedException {
        //一共放置四个线程

        //第一个线程交给核心线程执行
        threadPool2.execute(()->{
            System.out.println(Thread.currentThread().getName()+"第一任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        //因为核心线程到达最大值，第二个线程放进任务队列
        threadPool2.execute(()->{
            System.out.println(Thread.currentThread().getName()+"第二任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        //因为核心线程已满，任务队列已满，第三个线程交给新开的普通线程
        threadPool2.execute(()->{
            System.out.println(Thread.currentThread().getName()+"第三任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        //因为核心线程已满，任务队列已满，总线程数已满，执行拒绝策略，直接抛弃
        threadPool2.execute(()->{
            System.out.println(Thread.currentThread().getName()+"第四任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        Thread.sleep(100000);

        System.out.println("全部任务执行完成！");
    }

Connected to the target VM, address: '127.0.0.1:57607', transport: 'socket'
pool-3-thread-1第一任务开始执行
pool-3-thread-2第三任务开始执行
pool-3-thread-1第二任务开始执行

4 ThreadPoolExecutor.DiscardOldestPolicy

把最早未处理的任务丢弃

  //第四种拒绝策略，抛弃掉队列中最早未处理的任务需求
    //最大核心线程 1
    //最大线程 2
    //队列长度 1
    private static ThreadPoolExecutor threadPool3 = new ThreadPoolExecutor(1,2,10, TimeUnit.SECONDS,new ArrayBlockingQueue<>(1),new ThreadPoolExecutor.DiscardOldestPolicy());


    public static void main(String[] args) throws InterruptedException {
        //一共放置四个线程

        //第一个线程交给核心线程执行
        threadPool3.execute(()->{
            System.out.println(Thread.currentThread().getName()+"第一任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        //因为核心线程到达最大值，第二个线程放进任务队列
        threadPool3.execute(()->{
            System.out.println(Thread.currentThread().getName()+"第二任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        //因为核心线程已满，任务队列已满，第三个线程交给新开的普通线程
        threadPool3.execute(()->{
            System.out.println(Thread.currentThread().getName()+"第三任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        //因为核心线程已满，任务队列已满，总线程数已满，执行拒绝策略，抛弃已经在队列中的第二任务，将第四任务加入任务队列
        threadPool3.execute(()->{
            System.out.println(Thread.currentThread().getName()+"第四任务开始执行");
            try {
                //睡10秒
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        Thread.sleep(100000);

        System.out.println("全部任务执行完成！");
    }

Connected to the target VM, address: '127.0.0.1:57682', transport: 'socket'
pool-4-thread-1第一任务开始执行
pool-4-thread-2第三任务开始执行
pool-4-thread-2第四任务开始执行
Java并发编程系列27:ThreadPoolExecutor的4种拒绝策略
fen_fen的专栏
02-13 8415
ThreadPoolExecutor拒绝策略
45.自定义线程池（三）-拒绝策略
卷土的博客
06-03 1481
在原来的基础上添加了 带超时时间的阻塞添加方法，offer方法。
Java ThreadPoolExecutor的拒绝策略
m0_73311735的博客
08-30 2025
当线程池提供的拒绝策略无法满足要求时，我们可以采用自定义的拒绝策略，只需要实现RejectedExecutionHandler接口即可{@Override{new Thread(r,"线程:"+new Random().nextInt(10)).start();}}1,2,10,复制代码thread name:客户线程:6,执行:线程5thread name:pool-1-thread-1,执行:线程0thread name:客户线程:8,执行:线程4。...
Java 线程池四种拒绝策略
qq_45562973的博客
04-27 1663
🚀 优质资源分享 🚀 学习路线指引（点击解锁） 知识定位 人群定位 🧡 Python实战微信订餐小程序 🧡 进阶级 本课程是python flask+微信小程序的完美结合，从项目搭建到腾讯云部署上线，打造一个全栈订餐系统。 💛Python量化交易实战💛 入门级 手把手带你打造一个易扩展、更安全、效率更高的量化交易系统 jdk1.5版本新增了 JUC 并发包，其中一个包含线程池。 四种拒绝策略： 拒绝策略类型 说明 1 ThreadPoolExecutor.Abo
线程池的拒绝策略
DavenportChen的博客
05-24 618
线程池的拒绝策略拒绝策略：1.AbortPolicy（默认拒绝策略）：2. CallerRunsPolicy（使用调用线程池的线程来执行任务 ）：2.DiscardPolicy （忽略新任务）：4.DiscardOldestPolicy（忽略老任务）：5.自定义拒绝策略： 拒绝策略： （JDK提供了4种，另外也可以自定义拒绝策略，因此总共有5种。） 线程池中的线程已经用完了，无法继续为新任务服务，同时，等待队列也已经排满了，再也塞不下新任务了。这时候我们就需要拒绝策略机制合理的处理这个问题。 JDK 内置的
线程池的拒绝策略应该怎么选
sutingStart的博客
01-31 1489
拒绝策略会通知调用者任务无法被线程池处理。示例：AbortPolicy拒绝策略允许调用者线程自己执行被拒绝的任务。示例：CallerRunsPolicy拒绝策略静默地丢弃无法处理的任务，不执行也不抛出异常。提示：以下是本篇文章正文内容，下面案例可供参考在选择使用哪种拒绝策略时，你应该考虑到应用程序的具体需求和行为。例如，可以基于任务的重要程度和接受程度，系统的容错性，以及任务丢失对系统可能产生的后果。
Java线程池ThreadPoolExecutor背后的秘密与实践
热门推荐
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
05-12 170万+
本文深入分析了Java线程池ThreadPoolExecutor的工作原理、核心参数以及配置策略。通过详细讲解线程池的创建、任务调度和线程管理机制，帮助开发者理解如何高效使用线程池来处理并发任务。文章还探讨了常见的性能瓶颈和优化方法，如合理配置线程池参数、选择适当的拒绝策略等，旨在提升应用的并发处理能力和稳定性。最终，读者将能够根据不同场景灵活调整线程池配置，从而有效提升系统性能。
手写线程池实践 自定义BlockingQueue和拒绝策略
trigger的博客
06-04 428
/* 手写线程池以及拒绝策略，使用到的设计模式： 享元模式（池化技术） 策略模式（拒绝策略 提高程序扩展性） 线程池中 有一些线程去执行任务 worker 继承 thread实现 起初没有线程 如果任务来了直接 创建线程并且执行 worker.start() 任务数量大于一定的阈值后 就放入任务队列中 放入队列时采用lock 线程池就像调度者 不断的检查队列中是否
精选资源
线程池详解：线程池七大核心参数、线程池工作原理、线程池的创建方式、线程池的拒绝策略、如何合理分配线程池大小
04-05
四、线程池的拒绝策略 1. AbortPolicy：默认策略，抛出RejectedExecutionException异常，终止执行。 2. CallerRunsPolicy：调用者运行，主线程直接执行被拒绝的任务。 3. DiscardPolicy：丢弃策略，默默丢弃被拒绝...
多线程之线程池的拒绝策略，以及生产环境如何合理设置参数（十二）
努力+坚持，而且还很年轻
02-24 1678
上篇博文，我们详细的介绍了[线程池的原理](https://blog.youkuaiyun.com/jiuqiyuliang/article/details/102383861)，这篇我们重点介绍线程池的饱和策略，以及生产环境如何合理设置参数。为什么我们要单独拿出一篇博文来写饱和策略以及配置参数呢？因为自定义线程池配置的重点就两项：一、选择合适的线程池类型，二、配置合适的饱和策略与参数。
线程池-线程池的拒绝策略
欢迎订阅我的“JAVA全栈开发笔记（全）”专栏，价格优惠，仅需19.9元。
05-18 1223
AbortPolicy（中止策略） CallerRunsPolicy（调用者运行策略） DiscardPolicy（丢弃策略） DiscardOldestPolicy（弃老策略）
线程池的四大拒绝策略
一名编程小白的Java学习日志
03-24 3902
线程池的四大拒绝策略
如何使用Java线程池的拒绝策略
jack_shuai的博客
08-26 1399
一、线程池核心参数 ThreadPoolExecutor最核心的构造方法 : 二、线程增长过程 三、线程池拒绝策略 拒绝策略RejectedExecutionHandler做一下详细的工作:在使用线程池并且使用有界队列的时候，如果队列满了，任务添加到线程池的时候就会有问题，针对这些问题java线程池提供了以下几种策略： (1)AbortPolicy (2)DiscardPoli...
线程池的四种拒绝策略
weixin_71786285的博客
08-21 1241
当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize时，如果还有任务到来就会采取任务拒绝策略。 通常有以下四种策略： AbortPolicy （默认）：当任务添加到线程池中被拒绝时，它会直接抛出异常。 CallerRunsPolicy ：当任务添加到线程池中被拒绝时，那么主线程会自己去执行该任务。该策略既不会抛弃任务，也不会抛出异常，而是将某些任务退回，从而降低新任务的流量。 DiscardOldestPolicy：当任务添加到线
线程池的各种拒绝策略和使用场景
wobenqingfeng的专栏
06-16 1493
根据具体的应用需求，选择适合的拒绝策略非常重要。需要考虑任务丢失的可接受程度、任务优先级、对异常处理的需求等因素。另外，有些线程池实现还提供了自定义拒绝策略的扩展点，可以根据实际需求自定义实现特定的拒绝策略。需要注意的是，无论使用哪种拒绝策略，都应该在提交任务前合理估计线程池的边界和资源限制，以避免因过度提交任务而导致系统不稳定或资源耗尽。线程池的拒绝策略决定了当线程池无法接受新任务时，如何处理这些被拒绝的任务。
线程池-拒绝策略
假女吖的博客
07-14 1656
当 Java 提供的这四个拒绝策略你觉得不好用时，你可以自己定义这个拒绝策略来处理。也就是提供接口的实现即可。10,60,// 使用当发生拒绝策略的时候使用forkJoinPool这个线程来执行任务@Override10 个被执行，10 个被执行。当然这里不建议使用这种方式来处理，当大量任务会被执行拒绝策略的时候，这会导致的线程池无线扩充，最终导致内存异常等问题。这里只是举例慎用！！！！当然这里不建议使用这种方式来处理，当大量任务会被执行拒绝策略的时候，这会导致。
线程池拒绝策略（超详细讲解）
2201_75456895的博客
05-27 2522
共用四种拒绝策略分别为： AbortPolicy，CallerRunsPolicy，DiscardPolicy，DiscardOldestPolicy 它们都是；下面的 MyRunnable 类用来描述一个任务。
线程池的拒绝策略：优化处理能力的关键
Aili_0210的博客
07-22 1243
在多线程编程中，线程池是一种常用的工具，可以有效管理和调度大量的线程任务。然而，在高负载情况下，线程池可能无法接受新的任务，这就需要定义一种拒绝策略来处理这种情况。本文将介绍线程池的拒绝策略，以及如何选择合适的策略来优化处理能力。线程池的拒绝策略是在线程池无法接受新任务时采取的一种处理方式。当线程池中的线程已经达到最大容量并且队列已满时，新的任务将会被拒绝。拒绝策略定义了线程池如何处理这些被拒绝的任务，以避免任务丢失或造成系统崩溃。
java线程池拒绝策略
最新发布
03-17
### Java线程池拒绝策略概述 Java线程池提供了多种内置的拒绝策略来处理任务提交超出线程池容量的情况。这些策略可以通过`ThreadPoolExecutor`类进行设置，具体实现依赖于`RejectedExecutionHandler`接口。 #### 内置拒绝策略详解 1. **AbortPolicy** 默认的拒绝策略，在无法执行新任务时会抛出`RejectedExecutionException`异常[^4]。这种方式适用于希望程序立即失败并报告错误的场景。 2. **CallerRunsPolicy** 当任务被拒绝时，该策略会让提交任务的线程（即调用者线程）执行这个任务。这可能会降低系统的整体吞吐量，但在某些情况下可以缓解压力。 3. **DiscardPolicy** 静默丢弃被拒绝的任务而不做任何通知或记录。这种策略适合那些允许丢失部分任务的应用场景。 4. **DiscardOldestPolicy** 试图丢弃最旧的一个请求以便为当前任务腾出空间。此策略可能会影响较早提交的任务完成时间。 #### 自定义拒绝策略 除了上述四种标准策略外，还可以通过继承`RejectedExecutionHandler`接口来自定义拒绝逻辑。例如，`AbortPolicyWithReport`扩展了默认的`AbortPolicy`，可以在拒绝任务的同时提供额外的日志或其他操作支持[^2]。 以下是创建自定义拒绝策略的一个简单例子： ```java public class CustomRejectPolicy implements RejectedExecutionHandler { @Override public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { System.err.println("Task " + r.toString() + " rejected from " + executor.toString()); // 可在此处添加其他处理逻辑，比如保存到队列或者日志记录 } } ``` #### 设置拒绝策略的方法 要在线程池中应用特定的拒绝策略，需在初始化`ThreadPoolExecutor`实例时指定它。下面是一个完整的示例代码片段展示如何配置带有不同拒绝策略的线程池： ```java import java.util.concurrent.*; public class ThreadPoolExample { public static void main(String[] args) { int corePoolSize = 2; int maximumPoolSize = 4; long keepAliveTime = 10L; TimeUnit unit = TimeUnit.SECONDS; BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(2); // 创建具有CallerRunsPolicy拒绝策略的线程池 ThreadPoolExecutor threadPool = new ThreadPoolExecutor( corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, new ThreadPoolExecutor.CallerRunsPolicy() ); // 提交超过线程池承载能力的任务数测试效果 for (int i = 0; i < 10; i++) { final int taskNumber = i; threadPool.submit(() -> { try { Thread.sleep(2000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } System.out.println("Executing Task " + taskNumber); }); } threadPool.shutdown(); } } ``` #### 最佳实践建议 为了更高效地利用线程池资源并减少因拒绝策略引发的问题，应遵循以下几点最佳实践： - 合理设定核心线程数(`corePoolSize`)和最大线程数(`maximumPoolSize`)以匹配实际负载需求[^3]。 - 调整阻塞队列大小(`workQueue`)以平衡内存占用与响应速度之间的关系。 - 定期监控线程池运行状况，包括活动线程计数、已完成任务总数等指标，并据此动态调整参数。 - 根据业务特点选择合适的拒绝策略；如果需要更高的灵活性，则考虑开发定制化解决方案。
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值