精华内容
下载资源
问答
  • 线程池拒绝策略

    2021-08-10 21:40:41
    文章目录前言四种线程池拒绝策略线程池默认的拒绝策略设置线程池拒绝策略拒绝策略场景分析AbortPolicyDiscardPolicyDiscardOldestPolicyCallerRunsPolicy总结 前言 线程池,相信很多人都有用过,没用过相信的也有...

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档


    前言

    线程池,相信很多人都有用过,没用过相信的也有学习过。但是,线程池的拒绝策略,相信知道的人会少许多。


    四种线程池拒绝策略

    当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize时,如果还有任务到来就会采取任务拒绝策略,通常有以下四种策略:

    • ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
    • ThreadPoolExecutor.DiscardPolicy:丢弃任务,但是不抛出异常。
    • ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列最前面的任务,然后重新提交被拒绝的任务
    • ThreadPoolExecutor.CallerRunsPolicy:由调用线程(提交任务的线程)处理该任务

    线程池默认的拒绝策略

    既然有四种拒绝策略可以选择,那么线程池的默认拒绝策略是什么呢?查看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<Runnable> queue = new ArrayBlockingQueue<>(100);
            ThreadFactory factory = r -> new Thread(r, "test-thread-pool");
            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。运行代码:

    【317期】面试官:说说你知道多少种线程池拒绝策略

    结果是符合预期的,这也证明了线程池的默认拒绝策略是ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

    设置线程池拒绝策略

    如果我们想要根据实际业务场景需要,设置其他的线程池拒绝策略,可以通过ThreadPoolExecutor重载的构造方法进行设置:

    【317期】面试官:说说你知道多少种线程池拒绝策略

    现在的开发中,相信大家都有使用spring,其实我们也可以通过spring提供的org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor构建线程池。如下:

    在这里插入图片描述

    @Configuration
    public class TaskExecutorConfig implements AsyncConfigurer {
        /**
         * Set the ThreadPoolExecutor's core pool size.
         */
        private static final int CORE_POOL_SIZE = 5;
        /**
         * Set the ThreadPoolExecutor's maximum pool size.
         */
        private static final int MAX_POOL_SIZE = 5;
        /**
         * Set the capacity for the ThreadPoolExecutor's BlockingQueue.
         */
        private static final int QUEUE_CAPACITY = 1000;
    
        /**
         * 通过重写getAsyncExecutor方法,制定默认的任务执行由该方法产生
         * <p>
         * 配置类实现AsyncConfigurer接口并重写getAsyncExcutor方法,并返回一个ThreadPoolTaskExevutor
         * 这样我们就获得了一个基于线程池的TaskExecutor
         */
        @Override
        public Executor getAsyncExecutor() {
            ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
            taskExecutor.setCorePoolSize(CORE_POOL_SIZE);
            taskExecutor.setMaxPoolSize(MAX_POOL_SIZE);
            taskExecutor.setQueueCapacity(QUEUE_CAPACITY);
            taskExecutor.initialize();
            taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
            return taskExecutor;
        }
    }
    

    通过ThreadPoolTaskExecutorsetRejectedExecutionHandler设置拒绝策略即可。

    拒绝策略场景分析

    AbortPolicy

    ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

    A handler for rejected tasks that 
    throws a {@code 
    RejectedExecutionException}.
    

    这是线程池默认的拒绝策略,在任务不能再提交的时候,抛出异常,及时反馈程序运行状态。如果是比较关键的业务,推荐使用此拒绝策略,这样子在系统不能承载更大的并发量的时候,能够及时的通过异常发现。

    DiscardPolicy

    ThreadPoolExecutor.DiscardPolicy:丢弃任务,但是不抛出异常。如果线程队列已满,则后续提交的任务都会被丢弃,且是静默丢弃。

    A handler for rejected tasks that silently discards therejected task.
    

    使用此策略,可能会使我们无法发现系统的异常状态。建议是一些无关紧要的业务采用此策略。

    DiscardOldestPolicy

    ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列最前面的任务,然后重新提交被拒绝的任务。

    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.
    

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

    CallerRunsPolicy

    ThreadPoolExecutor.CallerRunsPolicy:由调用线程处理该任务

    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 void main(String[] args) {
    
        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10);
        ThreadFactory factory = r -> new Thread(r, "test-thread-pool");
        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,打印输出线程的名称。执行结果如下:

    【317期】面试官:说说你知道多少种线程池拒绝策略

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

    总结

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

    展开全文
  • 四种线程池拒绝策略

    万次阅读 多人点赞 2019-08-08 20:50:38
    二、四种线程池拒绝策略 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize时,如果还有任务到来就会采取任务拒绝策略,通常有以下四种策略: ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出...

    一、前言


    线程池,相信很多人都有用过,没用过相信的也有学习过。但是,线程池的拒绝策略,相信知道的人会少许多。


    二、四种线程池拒绝策略


    当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize时,如果还有任务到来就会采取任务拒绝策略,通常有以下四种策略:
    ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 ThreadPoolExecutor.DiscardPolicy:丢弃任务,但是不抛出异常。 ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列最前面的任务,然后重新提交被拒绝的任务 ThreadPoolExecutor.CallerRunsPolicy:由调用线程(提交任务的线程)处理该任务


    三、线程池默认的拒绝策略


    既然有四种拒绝策略可以选择,那么线程池的默认拒绝策略是什么呢?查看

    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<Runnable> queue = new ArrayBlockingQueue<>(100);
    ThreadFactory factory = r -> new Thread(r, "test-thread-pool");
    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异常。


    四、设置线程池拒绝策略


    如果我们想要根据实际业务场景需要,设置其他的线程池拒绝策略,可以通过ThreadPoolExecutor重载的构造方法进行设置:


    现在的开发中,相信大家都有使用spring,其实我们也可以通过spring提供的org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor构建线程池。如下:


    @Configuration
    public class TaskExecutorConfig implements AsyncConfigurer {
    /**
    * Set the ThreadPoolExecutor's core pool size.
    */

    private static final int CORE_POOL_SIZE = 5;
    /**
    * Set the ThreadPoolExecutor's maximum pool size.
    */

    private static final int MAX_POOL_SIZE = 5;
    /**
    * Set the capacity for the ThreadPoolExecutor's BlockingQueue.
    */

    private static final int QUEUE_CAPACITY = 1000;
    /**
    * 通过重写getAsyncExecutor方法,制定默认的任务执行由该方法产生
    * <p>
    * 配置类实现AsyncConfigurer接口并重写getAsyncExcutor方法,并返回一个ThreadPoolTaskExevutor
    * 这样我们就获得了一个基于线程池的TaskExecutor
    */

    @Override
    public Executor getAsyncExecutor() {
    ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    taskExecutor.setCorePoolSize(CORE_POOL_SIZE);
    taskExecutor.setMaxPoolSize(MAX_POOL_SIZE);
    taskExecutor.setQueueCapacity(QUEUE_CAPACITY);
    taskExecutor.initialize();
    taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
    return taskExecutor;
    }
    }


    五、拒绝策略场景分析


    (1)AbortPolicy
    AbortPolicy

    ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

    A handler for rejected tasks that throws a {@code RejectedExecutionException}.

    这是线程池默认的拒绝策略,在任务不能再提交的时候,抛出异常,及时反馈程序运行状态。如果是比较关键的业务,推荐使用此拒绝策略,这样子在系统不能承载更大的并发量的时候,能够及时的通过异常发现。

    (2)DiscardPolicy

    ThreadPoolExecutor.DiscardPolicy:丢弃任务,但是不抛出异常。如果线程队列已满,则后续提交的任务都会被丢弃,且是静默丢弃。

    A handler for rejected tasks that silently discards therejected task.
    

    使用此策略,可能会使我们无法发现系统的异常状态。建议是一些无关紧要的业务采用此策略。例如,本人的博客网站统计阅读量就是采用的这种拒绝策略。

    (3)DiscardOldestPolicy

    ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列最前面的任务,然后重新提交被拒绝的任务。

    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.

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

    (4)CallerRunsPolicy

    ThreadPoolExecutor.CallerRunsPolicy:由调用线程处理该任务

    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 void main(String[] args) {
     BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10);
     ThreadFactory factory = r -> new Thread(r, "test-thread-pool");
     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也执行了任务,这正说明了此拒绝策略由调用线程(提交任务的线程)直接执行被丢弃的任务的。

    六、总结


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

    展开全文
  • 线程池拒绝策略详解

    千次阅读 2019-10-16 09:55:11
    线程池拒绝策略详解 JDK中已经预设了4种线程池拒绝策略,下面结合场景详细聊聊这些策略的使用场景,以及我们还能扩展哪些拒绝策略。 池化设计思想 池话设计应该不是一个新名词。我们常见的如java线程池、jdbc连接...

    线程池拒绝策略详解

    • JDK中已经预设了4种线程池拒绝策略,下面结合场景详细聊聊这些策略的使用场景,以及我们还能扩展哪些拒绝策略。

    池化设计思想

    • 池话设计应该不是一个新名词。我们常见的如java线程池、jdbc连接池、redis连接池等就是这类设计的代表实现。这种设计会初始预设资源,解决的问题就是抵消每次获取资源的消耗,如创建线程的开销,获取远程连接的开销等。就好比你去食堂打饭,打饭的大妈会先把饭盛好几份放那里,你来了就直接拿着饭盒加菜即可,不用再临时又盛饭又打菜,效率就高了。除了初始化资源,池化设计还包括如下这些特征:池子的初始值、池子的活跃值、池子的最大值等,这些特征可以直接映射到java线程池和数据库连接池的成员属性中。

    线程池触发拒绝策略的时机

    • 和数据库连接池不一样,线程池除了初始化大小和池子最大值,还多了一个阻塞队列来缓冲。数据库连接池一般请求的连接数超过连接池的最大值的时候就会触发拒绝策略,策略一般是阻塞等待设置的时间或者直接抛异常。而线程池的触发时机如下图:
      image

    • 如图,只有当队列缓冲区满了才会触发拒绝策略。

    JDK内置4种线程池拒绝策略

    拒绝策略接口定义

    public interface RejectedExecutionHandler {
        void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
    }
    
    • 接口定义很明确,当触发拒绝策略时,线程池会调用你设置的具体的策略,将当前提交的任务以及线程池实例本身传递给你处理,不同场景会有不同的考虑,下面看下JDK内置了哪些拒绝策略

    CallerRunsPolicy(调用者运行策略)

    public satatic class CallerRunsPolicy implements RejectExecutionHandler{
        public CallerRunsPolicy(){}
        
        public void rejectedExecution(Runnable r,ThreadPoolExecutor e){
            if(!e.isShutdown()){
                r.run();
            }
        }
    }
    
    • 功能:当触发拒绝策略时,只要线程池没有关闭,就由提交任务的当前线程处理。
    • 使用场景:一般在不允许失败的、对性能要求不高、并发量较小的场景下使用,因为线程池一般情况下不会关闭,也就是提交的任务一定会被运行,但是由于是调用者线程自己执行的,当多次提交任务时,就会阻塞后续任务执行,性能和效率自然就慢了。

    AbortPolicy(中止策略)

        public static class AbortPolicy implements RejectedExecutionHandler{
            public AbortPolicy(){}
            
            public void rejectedExecution(Runnable r,ThreadPoolExecutor e){
                throw new RejectedExecutionException("Task " + r.toString() +
                                                     " rejected from " +
                                                     e.toString());
            }
        }
    
    • 功能:当触发拒绝策略时,直接抛出拒绝执行的异常,中止策略的意思也就是打断当前执行流程
    • 使用场景:这个就没有特殊的场景了,但是有一点要正确处理抛出的异常。ThreadPoolExecutor中默认的策略就是AbortPolicy,ExecutorService接口的系列ThreadPoolExecutor因为都没有显示的设置拒绝策略,所以默认的都是这个。但是请注意,ExecutorService中的线程池实例队列都是无界的,也就是说把内存撑爆了都不会触发拒绝策略。当自己自定义线程池实例时,使用这个策略一定要处理好触发策略时抛的异常,因为他会打断当前的执行流程。

    DiscardPolicy(丢弃策略)

        public static class DiscardPolicy implements RejectedExecutionHandler {
    
            public DiscardPolicy() { }
    
            public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            }
        }
    
    • 功能:直接静悄悄的丢弃这个任务,不触发任何动作
    • 使用场景:如果你提交的任务无关紧要,你就可以使用它 。因为它就是个空实现,会悄无声息的吞噬你的的任务。所以这个策略基本上不用了

    DiscardOldestPolicy(弃老策略)

    public static class DiscardOldestPolicy implements RejectExecutionHandler{
        public DiscardOldestPolicy(){}
        
        public void rejectedExecution(Runnable r,ThreadPoolExecutor e){
            if(!e.isShutdown()){
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }
    
    • 功能:如果线程池未关闭,就弹出队列头部的元素,然后尝试执行
    • 使用场景:这个策略还是会丢弃任务,丢弃时也是毫无声息,但是特点是丢弃的是老的未执行的任务,而且是待执行优先级较高的任务。基于这个特性,想到的场景就是,发布消息和修改消息,当消息发布出去后,还未执行,此时更新的ixaoxi又来了,这个时候未执行的消息的版本比现在提交的消息版本要低就可以被丢弃了。因为队列中还有可能存在消息版本更低的消息会排队执行,所以在真正处理消息的时候一定要做好消息的版本比较。

    第三方实现的拒绝策略

    dubbo的线程拒绝策略

    public class AbortPolicyWithReport extends ThreadPoolExecutor.AbortPolicy{
        protected static final Logger logger = LoggerFactory.getLogger(AbortPolicyWithReport.class);
        
        private final String threadName;
        
        private final URL url;
        
        private static volatile long lastPringTime = 0;
        
        private static Semaphore guard = new Semaphore(1);
        
        public AbortPolicyWithReport(String threadName, URL url) {
            this.threadName = threadName;
            this.url = url;
        }
        
        @Override
        public void rejectedExecution(Runnable r,ThreadPoolExecutor e){
            String msg = String.format("Thread pool is EXHAUSTED!" +
                            " Thread Name: %s, Pool Size: %d (active: %d, core: %d, max: %d, largest: %d), Task: %d (completed: %d)," +
                            " Executor status:(isShutdown:%s, isTerminated:%s, isTerminating:%s), in %s://%s:%d!",
                    threadName, e.getPoolSize(), e.getActiveCount(), e.getCorePoolSize(), e.getMaximumPoolSize(), e.getLargestPoolSize(),
                    e.getTaskCount(), e.getCompletedTaskCount(), e.isShutdown(), e.isTerminated(), e.isTerminating(),
                    url.getProtocol(), url.getIp(), url.getPort());
            logger.warn(msg);
            dumpJStack();
            throw new RejectedExecutionException(msg);
        }
        
        private void dumpJStack(){
            //省略
        }
    }
    
    • 可以看到,当dubbo的拒绝策略被触发时,主要做了三件事情,原则就是尽量让使用清楚线程拒绝策略的真实原因
      • 输出了一条警告级别的日志,日志内容为线程池的详细设置参数,以及线程池当前的状态,还有当前拒绝任务的一些详细信息。可以说,这条日志,使用dubbo的有过生产运维经验的或多或少是见过的,这个日志简直就是日志打印的典范,其他的日志打印的典范还有spring。得益于这么详细的日志,可以很容易定位到问题所在
      • 输出当前线程堆栈详情,这个太有用了,当你通过上面的日志信息还不能定位问题时,案发现场的dump线程上下文信息就是你发现问题的救命稻草
      • 继续抛出拒绝执行异常,使本次任务执行失败,这个继承了JDK默认拒绝策略的特性

    Netty的线程池拒绝策略

    private static final class NewThreadRunsPolicy implements RejectedExecutionHandler {
        NewThreadRunsPolicy(){
            super();
        }
        
        public void rejectedExecution(Runnable r,ThreadPoolThread e){
            try{
                final Thread t = new Thread(r,"Temporary task executor");
                t.start();
            }catch(Throwable e){
                throw new RejectedExecutionException("Failed to start a new thread ",e);
            }
        }
    }
    
    • Netty中的实现很像JDK中的CallerRunsPolicy,舍不得丢弃任务。不同的是,CallerRunsPolicy是直接在调用者线程执行的任务。而Netty是新建了一个线程来处理的。所以,Netty的实现相较于调用者执行策略的使用面就可以扩展到支持高效率高性能的场景了。但是也要注意一点,Netty的实现里,在创建线程时未做任何的判断约束,也就是说只要系统还有自由就会创建新的线程来处理,直到new不出新的线程了,才会抛创建线程失败的异常

    activeMq的线程池拒绝策略

    new RejectedExecutionHandler(){
        @Override
        public void rejectedExecution(final Runnable r,final ThreadPoolThread e){
            try{
                executor.getQueue().offer(r,60,TimeUnit.SECONDS);
            }catch(InterruptedException e){
                throw new RejectedExecutionException("Interrupted waiting for BrokerService.worker");
            }
            
            throw new RejectedExecutionException("Timed Out while attempting
        }
    }
    
    • activeMq中的策略属于最大努力执行任务型,当触发拒绝策略时,在尝试一分钟的时间里重新将任务塞进队列,当一分钟超时还没成功时,就抛出异常。

    pinpoint中的线程池拒绝策略

    public class RejectedExecution implements RejectedExecutionHandler{
        private final RejectedExecutionHandler[] handlerChain;
        
        public static RejectedExecutionHandler build(List<RejectedExecutionHandler> chain){
            Objects.requireNonNull(chain,"handlerChain must not be null");
            RejectedExecutionHandler[] handlerChain = chain.toArray(new RejectedExecutionHandler());
            return new RejectedExecutionHandlerChain(handlerChain);
        }
        
        private RejectedExecutionHandlerChain(RejectedExecutionHandler[] handlerCahin){
            this.handlerChain = Objects.requireNonNull(handlerChain, "handlerChain must not be null");
        }
        
        @Override
        public void rejectedExecution(Runnable r,ThreadPoolExecutor executor){
            for(RejectedExecutionHandler rejectedExecutionHandler:handlerChain){
                rejectedExecutionHandler.rejectedExecution(r,executor);
            }
        }
    }
    
    • pinpoing的拒绝策略实现很有特点,和其他的实现都不同。他定义了一个拒绝策略链,包装了一个拒绝策略列表,当触发拒绝策略时,会将策略链中的rejectedExecution依次执行一遍。
    展开全文
  • Java线程池拒绝策略

    2020-03-30 22:34:52
    四种线程池拒绝策略 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize时,如果还有任务到来就会采取任务拒绝策略,通常有以下四种策略: ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出...

    前言

    线程池,相信很多人都有用过,没用过相信的也有学习过。但是,线程池的拒绝策略,相信知道的人会少许多。

    四种线程池拒绝策略

    当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize时,如果还有任务到来就会采取任务拒绝策略,通常有以下四种策略:

     

    ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
    ThreadPoolExecutor.DiscardPolicy:丢弃任务,但是不抛出异常。
    ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列最前面的任务,然后重新提交被拒绝的任务
    ThreadPoolExecutor.CallerRunsPolicy:由调用线程(提交任务的线程)处理该任务
    

    线程池默认的拒绝策略

    既然有四种拒绝策略可以选择,那么线程池的默认拒绝策略是什么呢?查看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<Runnable> queue = new ArrayBlockingQueue<>(100);
            ThreadFactory factory = r -> new Thread(r, "test-thread-pool");
            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。运行代码:

    image

    结果是符合预期的,这也证明了线程池的默认拒绝策略是ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

    设置线程池拒绝策略

    如果我们想要根据实际业务场景需要,设置其他的线程池拒绝策略,可以通过ThreadPoolExecutor重载的构造方法进行设置:

    image

    现在的开发中,相信大家都有使用spring,其实我们也可以通过spring提供的org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor构建线程池。如下:

    image

     

    @Configuration
    public class TaskExecutorConfig implements AsyncConfigurer {
        /**
         * Set the ThreadPoolExecutor's core pool size.
         */
        private static final int CORE_POOL_SIZE = 5;
        /**
         * Set the ThreadPoolExecutor's maximum pool size.
         */
        private static final int MAX_POOL_SIZE = 5;
        /**
         * Set the capacity for the ThreadPoolExecutor's BlockingQueue.
         */
        private static final int QUEUE_CAPACITY = 1000;
    
        /**
         * 通过重写getAsyncExecutor方法,制定默认的任务执行由该方法产生
         * <p>
         * 配置类实现AsyncConfigurer接口并重写getAsyncExcutor方法,并返回一个ThreadPoolTaskExevutor
         * 这样我们就获得了一个基于线程池的TaskExecutor
         */
        @Override
        public Executor getAsyncExecutor() {
            ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
            taskExecutor.setCorePoolSize(CORE_POOL_SIZE);
            taskExecutor.setMaxPoolSize(MAX_POOL_SIZE);
            taskExecutor.setQueueCapacity(QUEUE_CAPACITY);
            taskExecutor.initialize();
            taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
            return taskExecutor;
        }
    }
    

    通过ThreadPoolTaskExecutor的setRejectedExecutionHandler设置拒绝策略即可。

    拒绝策略场景分析

    AbortPolicy

    ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

     

    A handler for rejected tasks that throws a {@code RejectedExecutionException}.
    

    这是线程池默认的拒绝策略,在任务不能再提交的时候,抛出异常,及时反馈程序运行状态。如果是比较关键的业务,推荐使用此拒绝策略,这样子在系统不能承载更大的并发量的时候,能够及时的通过异常发现。

    DiscardPolicy

    ThreadPoolExecutor.DiscardPolicy:丢弃任务,但是不抛出异常。如果线程队列已满,则后续提交的任务都会被丢弃,且是静默丢弃。

     

    A handler for rejected tasks that silently discards therejected task.
    

    使用此策略,可能会使我们无法发现系统的异常状态。建议是一些无关紧要的业务采用此策略。例如,本人的博客网站统计阅读量就是采用的这种拒绝策略。

    DiscardOldestPolicy

    ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列最前面的任务,然后重新提交被拒绝的任务。

     

    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.
    

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

    CallerRunsPolicy

    ThreadPoolExecutor.CallerRunsPolicy:由调用线程处理该任务

     

    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 void main(String[] args) {
    
        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10);
        ThreadFactory factory = r -> new Thread(r, "test-thread-pool");
        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();
                }
            });
        }
    }
    
    

    image

    把队列最大值改为10,打印输出线程的名称。执行结果如下:

    image

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

    总结

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



     

    展开全文
  • java线程池拒绝策略

    2020-01-30 11:00:29
    java线程池拒绝策略 线程池中,有三个重要的参数,决定了拒绝策略 corePoolSize 核心线程数,也即最小线程数 workQueue 阻塞队列,当阻塞队列饱和时,会扩充线程池中的线程数,最大到maximumPoolSize ...
  • 线程池拒绝策略应用场景简单回答:详细回答:1.AbortPolicy中止策略:丢弃任务并抛出RejectedExecutionException异常。2.DiscardPolicy丢弃策略:ThreadPoolExecutor.DiscardPolicy:丢弃任务,但是不抛出异常。如果...
  • Java线程池拒绝策略触发时机 当提交的任务数量大于maximumPoolSize + wordQueue时,Java会执行相应的拒绝策略,对于当前提交的任务进行处理。 JDK内置了那些拒绝策略 JDK1.5之后引入了线程池,同时也提供了4中拒绝...
  • 早在上个月,就要说写一篇除 java.util.concurrent包之外的四种线程池拒绝策略,开源框架如:ActiveMQ,Dubbo,PinPoint,Netty也都实现了符合自己业务的拒绝策略。 然而一直没有动手,直到今天手残的点开一篇博客如下...
  • 2020-10-09: 线程池拒绝策略分别使用在什么场景?前言线程池拒绝策略分别使用在什么场景? 前言 每日一题专栏 线程池拒绝策略分别使用在什么场景? 拒中丢老调(线程池拒绝策略:中止策略、丢弃策略、弃老策略、调用...
  • 一、缘由 很多人都知道或者用过线程池,线程池构造方法的参数中有...如果你稍微思考,就会发现不同的编程语言、算法、设计模式、存储方式、线程池拒绝策略等适用不同的场景。 (图片来源:美团技术) 启发:我们要做
  • 重温线程池拒绝策略

    2021-08-13 18:02:16
    线程池中的线程已经用完,等待队列也满了,无法为新提交的任务服务,可以通过拒绝策略来处理这个问题。 四种拒绝策略: 1.AbortPolicy策略:会抛出异常 2.CallerRunPolicy策略:只要线程池没关闭,会在调用者...
  • 四种线程池拒绝策略 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize时,如果还有任务到来就会采取任务拒绝策略,通常有以下四种策略: ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出...
  • JAVA线程池拒绝策略

    2019-11-25 16:47:09
    ThreadPoolExecutor的拒绝策略RejectedExecutionHandler 1.AbortPolicy 直接抛出异常 2.CallerRunsPolicy在任务被拒绝添加后,会调用当前线程池的所在的线程去执行被拒绝的任务。 3.DiscardPolicy 会让被线程池...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,621
精华内容 14,648
关键字:

线程池拒绝策略