ThreadPoolExecutor的RejectedExecu

java 线程池ThreadPoolExecutor的拒绝策略有：

    /**
     * A handler for rejected tasks that runs the rejected task
     * directly in the calling thread of the {@code execute} method,
     * unless the executor has been shut down, in which case the task
     * is discarded.
     */
    public static class CallerRunsPolicy implements RejectedExecutionHandler {
       ...
    }

    /**
     * A handler for rejected tasks that throws a
     * {@code RejectedExecutionException}.
     */
    public static class AbortPolicy implements RejectedExecutionHandler {
       ...
    }

    /**
     * A handler for rejected tasks that silently discards the
     * rejected task.
     */
    public static class DiscardPolicy implements RejectedExecutionHandler {
      ...
    }

    /**
     * A handler for rejected tasks that discards the oldest unhandled
     * request and then retries {@code execute}, unless the executor
     * is shut down, in which case the task is discarded.
     */
    public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        ...
    }

• CallerRunsPolicy : 当线程池和队列都满时，任务将会被任务的调用方线程执行，如果线程池关闭，那么任务将会被抛弃
• AbortPolicy ：当线程池和队列都满时，再有任务进来直接抛出RejectedExecutionException异常
• DiscardPolicy: 当线程池和队列都满时，再有任务进来，默默的将任务抛弃
• DiscardOldestPolicy： 当线程池和队列都满时，再有任务进来，抛弃最老的未处理的任务，然后重试该新进来的任务，如果线程池关闭，那么任务将会被抛弃

我们来看一个例子：

public static void main(String [] args) throws ExecutionException, InterruptedException {


        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1,1,
                                                                        500,
                                                                        TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(1),

                                                                        new ThreadPoolExecutor.CallerRunsPolicy()
                                                                        //new ThreadPoolExecutor.DiscardPolicy()
                                                                        //new ThreadPoolExecutor.DiscardOldestPolicy()
                                                                        //new ThreadPoolExecutor.AbortPolicy()
                                                                        );

        Future<String> taskOne = threadPoolExecutor.submit(()->{

            System.out.println("taskOne start...");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("taskOne 沉睡2秒结束...");
            return Thread.currentThread().getName();
        });


        Future<String> taskTwo = threadPoolExecutor.submit(()->{

            System.out.println("taskTwo start...");

            return Thread.currentThread().getName();

        });

        Future<String> taskThree = threadPoolExecutor.submit(()->{

            System.out.println("taskThree start...");

            return Thread.currentThread().getName();
        });

        System.out.println("taskOne:" + taskOne.get());

        System.out.println("taskTwo:" + taskTwo.get());

        System.out.println("taskThree:" + taskThree.get());

        threadPoolExecutor.shutdown();
    }

上述例子中创建了一个核心线程池数与最大线程池数都为1，阻塞队列长度也为1的线程池。然后启动三个任务，其中第一个任务执行等待2秒。

taskOne 占用了线程池中的唯一那个线程，taskTwo 进入了阻塞队列，这时队列已满，taskThree再进入线程池触发对应的策略。

• 当使用CallerRunsPolicy策略时打印：

taskOne start...
taskThree start...
taskOne 沉睡2秒结束...
taskOne:pool-1-thread-1
taskTwo start...
taskTwo:pool-1-thread-1
taskThree:main

可以看出taskOne和taskTwo执行者都是线程池内的那个线程，而taskThree的执行线程则是调用taskThree的main函数主线程

• 当使用DiscardPolicy()策略时打印：

taskOne start...
taskOne 沉睡2秒结束...
taskOne:pool-1-thread-1
taskTwo start...
taskTwo:pool-1-thread-1

默默抛弃策略不再打印taskThree 相关信息，并且程序在taskThree.get()处阻塞，线程池迟迟无法关闭。

• 当使用DiscardOldestPolicy()策略时打印：

taskOne start...
taskOne 沉睡2秒结束...
taskOne:pool-1-thread-1
taskThree start...

taskThree再进入线程池时，线程池根据策略把未执行的taskTwo给抛弃了，然后重试执行了taskThree，所以打印了taskThree start... ，但是，因为taskTwo 已被抛弃所以在调用taskTwo.get()时发生了阻塞。�所以没有System.out.println("taskThree:" + taskThree.get()); 相关的信息

• 当使用AbortPolicy()策略时打印：

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@31cefde0 rejected from java.util.concurrent.ThreadPoolExecutor@439f5b3d[Running, pool size = 1, active threads = 1, queued tasks = 1, completed tasks = 0]
taskOne start...
taskOne 沉睡2秒结束...
taskTwo start...

main主线程在taskThree的submit()时抛出异常，后面的信息都不打印了。