线程池的拒绝策略

前言

        线程池想必大家都有所耳闻,今天讲一讲线程池的几种基本的拒绝策略 

目录

前言

一.四种线程池拒绝策略（handler）  

二.线程池默认的拒绝策略

三.拒绝策略场景分析

1.AbortPolicy

2.DiscardPolicy

3.DiscardOldestPolicy

4.CallerRunsPolicy

四.总结

---

一.四种线程池拒绝策略（handler）  

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

AbortPolicy（默认）：丢弃任务并抛出 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 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。运行代码结果如下：

        结果是符合预期的，这也证明了线程池的默认拒绝策略是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 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
         */

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

3.DiscardOldestPolicy

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

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

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

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 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，打印输出线程的名称。执行结果如下：

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

四.总结

        本文介绍和演示了四种线程池拒绝策略，具体使用哪种策略，还得根据实际业务场景才能做出抉择。