【多线程】线程池拒绝策略

ThreadPoolExecutor处理任务的顺序

一个任务通过execute（Runnable）方法被添加到线程池，任务就是一个Runnable类型的对象，任务的执行方法就是Runnable类型对象的run（）方法。
当一个任务通过execute（）方法欲添加到线程池时，线程池采用的策略如下：

1、如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务
2、如果此时线程池中的数量等于corePoolSize，但是缓冲队列workQueue未满，那么任务被放入缓冲队列
3、如果此时线程池中的数量大于corePoolSize，缓冲对workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
4、如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过handler所指定的策略来处理此任务。

任务处理的优先级顺序为：
核心线程corePoolSize，任务队列workQueue，最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。当线程池中的线程数量大于corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池就动态的调整池中的线程数。

拒绝策略

JDK提供了四种拒绝策略：

AbortPolicy：直接抛出java.util.concurrent.RejectedExecutionException异常，系统正常工作，JDK采用的默认策略。
CallerRunsPolicy：用于被拒绝任务的处理程序，它直接在execute方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务。
DiscardOrderstPolicy：丢弃最老的请求，尝试再次提交当前任务。
DiscardPolicy：用于被拒绝任务的处理程序，默认情况下它将丢弃被拒绝的任务。

策略一：AbortPolicy()

直接抛出java.util.concurrent.RejectedExecutionException异常，系统正常工作，JDK采用的默认策略。

RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();

public class RejectMethod{

    private static class Worker implements Runnable {
        public void run() {
            System.out.println(Thread.currentThread().getName() + " is running");
        }
    }

    public static void main(String[] args) {

        int corePoolSize = 5;

        int maxPoolSize = 10;

        long keepAliveTime = 5;

        BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>(10);

        //拒绝策略1：将抛出 RejectedExecutionException.
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();

        ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize,
         maxPoolSize,
         keepAliveTime,
         TimeUnit.SECONDS,
         queue,
         handler);

        for(int i=0; i<100; i++) {
            executor.execute(new Worker());
        }
        executor.shutdown();
    }
}

执行结果如下：
在这里插入图片描述

处理源码如下：

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
     throw new RejectedExecutionException();
 }

策略二：CallerRunsPolicy()

用于被拒绝任务的处理程序，它直接在execute方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务。

RejectedExecutionHandler handler = new ThreadPoolExecutor.CallerRunsPolicy();

运行结果如下：
在这里插入图片描述
处理源码如下：

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
          r.run();
    }
 }

策略三：DiscardOrderstPolicy

丢弃最老的请求，尝试再次提交当前任务。

RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardOldestPolicy();

这样运行结果就不会有100个线程全部被执行。处理源码如下：

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
     if (!e.isShutdown()) {
         e.getQueue().poll();
         e.execute(r);
     }
}

策略四：DiscardPolicy

用于被拒绝任务的处理程序，默认情况下它将丢弃被拒绝的任务。

RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardPolicy();

源码处理如下：实际就是对线程不执行操作

public static class DiscardPolicy implements RejectedExecutionHandler {
 
        /**
         * Creates a <tt>DiscardPolicy</tt>.
         */
        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) {}
 
}

小结

这四种策略是独立无关的，是对任务拒绝处理的四种表现形式。最简单的方式就是直接丢弃任务，也有两种方式，到底是该丢弃哪一个任务，比如可以丢弃当前要加入队列的任务本身（DiscardPolicy）或者丢弃任务队列中最旧的任务（DiscardOldestPolicy）。丢弃最旧任务也不是简单的丢弃最旧的任务，而是有一些额外的处理。除了丢弃任务还可以直接抛出一个异常（RejectedExecutionException），这是比较简单的方式。抛出异常的方式（AbortPolicy）尽管实现方式比较简单，但是由于抛出一个RuntimeException，因此会中断调用者的处理过程。除了抛出异常以外还可以不进入线程池执行，在这种方式（CallerRunsPolicy）中任务将由调用者线程去执行。