2023-01-14  阅读(263)
原文作者: HelloWorld_EE 原文地址:https://blog.csdn.net/u010412719/category_6159934_2.html

《Java线程池》:任务拒绝策略

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

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

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

1、直接丢弃(DiscardPolicy)

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

3、抛异常(AbortPolicy)

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

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

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

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

        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

阅读全文
  • 点赞