任务拒绝策略

在没有分析线程池原理之前先来分析下为什么有任务拒绝的情况发生。

这里先假设一个前提：线程池有一个任务队列，用于缓存所有待处理的任务，正在处理的任务将从任务队列中移除。因此在任务队列长度有限的情况下就会出现新任务的拒绝处理问题，需要有一种策略来处理应该加入任务队列却因为队列已满无法加入的情况。另外在线程池关闭的时候也需要对任务加入队列操作进行额外的协调处理。

RejectedExecutionHandler提供了四种方式来处理任务拒绝策略

1、直接丢弃（DiscardPolicy）

2、丢弃队列中最老的任务(DiscardOldestPolicy)。

3、抛异常(AbortPolicy)

4、将任务分给调用线程来执行(CallerRunsPolicy)。

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

下面来看下这几种拒绝策略的例子。

使用直接丢弃任务本身的拒绝策略：DiscardPolicy
   

[Java] 纯文本查看 复制代码

?

001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117

import java.text.SimpleDateFormat;       import java.util.Date;       import java.util.concurrent.ArrayBlockingQueue;       import java.util.concurrent.BlockingQueue;       import java.util.concurrent.ThreadPoolExecutor;       import java.util.concurrent.TimeUnit;           public class ExecutorDemo {               private static  SimpleDateFormat sdf  = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");           public static void main(String[] args) {               int corePoolSize = 1;               int maximumPoolSize = 1;               BlockingQueue queue = new  ArrayBlockingQueue<Runnable>(1);               ThreadPoolExecutor pool = new ThreadPoolExecutor(corePoolSize,  maximumPoolSize,                       0, TimeUnit.SECONDS, queue ) ;               pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy ());               for(int i=0;i<10;i++){                   final int index = i;                   pool.submit(new Runnable(){                           @Override                       public void run() {                           log(Thread.currentThread().getName()+"begin run task :"+index);                           try {                               Thread.sleep(1000);                           } catch (InterruptedException e) {                               e.printStackTrace();                           }                           log(Thread.currentThread().getName()+" finish run  task :"+index);                       }                       });               }                   log("main thread before sleep!!!");               try {                   Thread.sleep(4000);               } catch (InterruptedException e) {                   e.printStackTrace();               }               log("before shutdown()");                   pool.shutdown();                   log("after shutdown(),pool.isTerminated=" + pool.isTerminated());               try {                   pool.awaitTermination(1000L, TimeUnit.SECONDS);               } catch (InterruptedException e) {                   e.printStackTrace();               }               log("now,pool.isTerminated=" + pool.isTerminated());           }               protected static void log(String string) {               System.out.println(sdf.format(new Date())+"  "+string);           }           }

运行结果：

    2016-08-04 22:29:21  main thread before sleep!!!
    2016-08-04 22:29:21  pool-1-thread-1begin run task :0
    2016-08-04 22:29:22  pool-1-thread-1 finish run  task :0
    2016-08-04 22:29:22  pool-1-thread-1begin run task :1
    2016-08-04 22:29:23  pool-1-thread-1 finish run  task :1
    2016-08-04 22:29:25  before shutdown()
    2016-08-04 22:29:25  after shutdown(),pool.isTerminated=false
    2016-08-04 22:29:25  now,pool.isTerminated=true
从结果可以看出，只有task0和task1两个任务被执行了。

为什么只有task0和task1两个任务被执行了呢？

过程是这样的：由于我们的任务队列的容量为1.当task0正在执行的时候，task1被提交到了队列中但是还没有执行，受队列容量的限制，submit提交的task2~task9就都被直接抛弃了。因此就只有task0和task1被执行了。

使用丢弃任务队列中比较久的任务的拒绝策略：DiscardOldestPolicy
如果将拒绝策略改为：DiscardOldestPolicy(丢弃队列中比较久的任务)

运行结果为：

    2016-08-04 22:31:58  pool-1-thread-1begin run task :0
    2016-08-04 22:31:58  main thread before sleep!!!
    2016-08-04 22:31:59  pool-1-thread-1 finish run  task :0
    2016-08-04 22:31:59  pool-1-thread-1begin run task :9
    2016-08-04 22:32:00  pool-1-thread-1 finish run  task :9
    2016-08-04 22:32:02  before shutdown()
    2016-08-04 22:32:02  after shutdown(),pool.isTerminated=false
    2016-08-04 22:32:02  now,pool.isTerminated=true
从结果可以看出，只有task0和task9被执行了。

使用将任务将由调用者线程去执行的拒绝策略：CallerRunsPolicy
如果将拒绝策略改为：CallerRunsPolicy(即不用线程池中的线程执行，而是交给调用方来执行)

运行结果为：

    2016-08-04 22:33:07  mainbegin run task :2
    2016-08-04 22:33:07  pool-1-thread-1begin run task :0
    2016-08-04 22:33:08  main finish run  task :2
    2016-08-04 22:33:08  mainbegin run task :3
    2016-08-04 22:33:08  pool-1-thread-1 finish run  task :0
    2016-08-04 22:33:08  pool-1-thread-1begin run task :1
    2016-08-04 22:33:09  pool-1-thread-1 finish run  task :1
    2016-08-04 22:33:09  main finish run  task :3
    2016-08-04 22:33:09  mainbegin run task :5
    2016-08-04 22:33:09  pool-1-thread-1begin run task :4
    2016-08-04 22:33:10  main finish run  task :5
    2016-08-04 22:33:10  mainbegin run task :7
    2016-08-04 22:33:10  pool-1-thread-1 finish run  task :4
    2016-08-04 22:33:10  pool-1-thread-1begin run task :6
    2016-08-04 22:33:11  main finish run  task :7
    2016-08-04 22:33:11  mainbegin run task :9
    2016-08-04 22:33:11  pool-1-thread-1 finish run  task :6
    2016-08-04 22:33:11  pool-1-thread-1begin run task :8
    2016-08-04 22:33:12  main finish run  task :9
    2016-08-04 22:33:12  main thread before sleep!!!
    2016-08-04 22:33:12  pool-1-thread-1 finish run  task :8
    2016-08-04 22:33:16  before shutdown()
    2016-08-04 22:33:16  after shutdown(),pool.isTerminated=false
    2016-08-04 22:33:16  now,pool.isTerminated=true

从结果可以看出，没有任务被抛弃，而是将由的任务分配到main线程中执行了。

小结
关于线程池的任务拒绝策略，我们要理解并记住，有如下的四种：

1、直接丢弃（DiscardPolicy）

2、丢弃队列中最老的任务(DiscardOldestPolicy)。

3、抛异常

4、将任务分给调用线程来执行。

参考资料
1、http://www.blogjava.net/xylz/archive/2011/01/08/342609.html