java八股文面试[多线程]——线程池拒绝策略

谁借莪１个温暖的怀抱￠ 2024-03-25 00:16 61阅读 0赞

![7367af8c6bac4502ba254844a63503aa.png][]

**四种线程池拒绝策略（handler）**   
当线程池的线程数达到最大线程数时，需要执行拒绝策略。拒绝策略需要实现 **RejectedExecutionHandler** 接口，并实现 **rejectedExecution**(Runnable r, ThreadPoolExecutor executor) 方法。不过 Executors 框架已经为我们实现了 4 种拒绝策略：

**Abort**Policy（默认）：**丢弃任务**并抛出 RejectedExecutionException 异常。  
CallerRunsPolicy：由**调用线程**处理该任务。  
DiscardPolicy：**丢弃任务**，但是不抛出异常。可以配合这种模式进行自定义的处理方式。  
DiscardOldestPolicy：**丢弃队列最早**的未处理任务，然后重新尝试执行任务。

**线程池默认的拒绝策略**  
查看java.util.concurrent.ThreadPoolExecutor类的源码，我们可以看到：

/**
     * The default rejected execution handler
     */
    private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();

线程池的默认拒绝策略为AbortPolicy，即丢弃任务并抛出RejectedExecutionException异常。我们可以通过代码来验证这一点，现有如下代码：

public class ThreadPoolTest {
     
        public static void main(String[] args) {
     
            BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(100);
            ThreadFactory factory = r -> new Thread(r, "TestThreadPool");
            ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5,
                    0L, TimeUnit.SECONDS, queue, factory);
            while (true) {
                executor.submit(() -> {
                    try {
                        System.out.println(queue.size());
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }
        }
     
    }

这里是一个默认的线程池，没有设置拒绝策略，设置了最大线程队列是100。运行代码结果如下：

![e7b8b34345804237bb093439fa203022.png][]

结果是符合预期的，这也证明了线程池的默认拒绝策略是ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

**拒绝策略场景分析**  
1.AbortPolicy  
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。源码解释如下:

/**
             * 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
             */

这是线程池默认的拒绝策略，在任务不能再提交的时候，抛出异常，及时反馈程序运行状态。如果是比较关键的业务，推荐使用此拒绝策略，这样子在系统不能承载更大的并发量的时候，能够及时的通过异常发现。

2.DiscardPolicy  
ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。如果线程队列已满，则后续提交的任务都会被丢弃，且是**静默丢弃**。源码解释如下:

/**
             * 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
             */

使用此策略，可能会使我们无法发现系统的异常状态。建议是一些**无关紧要**的业务采用此策略。例如，某些视频网站**统计视频的播放量**就是采用的这种拒绝策略。

**3.DiscardOldestPolicy**  
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列**最前面**的任务，然后重新提交被拒绝的任务。源码解释如下:

此拒绝策略，是一种喜新厌旧的拒绝策略。是否要采用此种拒绝策略，还得根据实际业务是否允许丢弃老任务来认真衡量。

**4.CallerRunsPolicy**  
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务 源码解释如下:

/**
             * 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 static void main(String[] args) {
     
        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10);
        ThreadFactory factory = r -> new Thread(r, "TestThreadPool");
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5,
                                                             0L, TimeUnit.SECONDS, queue, factory, new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + ":执行任务");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }

把队列最大值改为10，打印输出线程的名称。执行结果如下：

![6f3bf965d1e34cdeb3e9dc0a6f1aab94.png][]

通过结果可以看到，主线程main也执行了任务，这正说明了此拒绝策略由调用线程（提交任务的线程）直接执行被丢弃的任务的。

知识来源：

[【23版面试突击】你知道线程池有哪几种拒绝策略吗？\_哔哩哔哩\_bilibili][23_bilibili]

[线程池的拒绝策略\_线程池拒绝策略\_小赵在练琴的博客-CSDN博客][-CSDN]

[7367af8c6bac4502ba254844a63503aa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/03d24dcb6ca64945b30e5de793ae3fc4.png
[e7b8b34345804237bb093439fa203022.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/6c945b096e5b47588fee1c06232be526.png
[6f3bf965d1e34cdeb3e9dc0a6f1aab94.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/68b7ac14197a4229a2c73a036db5f574.png
[23_bilibili]: https://www.bilibili.com/video/BV1M24y1z7BR?p=172&vd_source=7ec3a2ec18181a9b64c9a3246305e511
[-CSDN]: https://blog.csdn.net/annotation_PLZ/article/details/126455475