JAVA线程池自定义拒绝策略以及利用反射获取任务参数

Lane_Wang

已于 2025-01-06 16:43:57 修改

阅读量3.7k

点赞数 2

CC 4.0 BY-SA版权

分类专栏： Java 文章标签： java 后端多线程

于 2021-11-25 14:03:27 首次发布

本文链接：https://blog.csdn.net/baidu_17353319/article/details/121532270

Java 专栏收录该内容

1 篇文章

订阅专栏

本文探讨了线程池拒绝策略的触发条件，包括AbortPolicy、DiscardPolicy、DiscardOldestPolicy和CallerRunsPolicy四种策略，并详细介绍了如何自定义拒绝策略。通过反射技术，可以在拒绝策略中获取任务参数，为业务处理提供更多信息。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言

线程池拒绝策略的触发条件

AbortPolicy拒绝并抛出异常

DiscardPolicy丢弃任务并不做任何操作

DiscardOldestPolicy丢弃最老的任务

CallerRunsPolicy调用主线程处理

自定义拒绝策略

前言

近阶段工作中遇到需要自定义拒绝策略的情况，网上查阅资料，大多文章都写的比较简单，所以花点时间自己研究下。

线程池拒绝策略的触发条件

一般情况下，我们都会手动创建一个有界线程池

@Bean("myThread")
public ThreadPoolTaskExecutor myThread(){
    ThreadPoolTaskExecutor executor=new ThreadPoolTaskExecutor();
//核心线程数
    executor.setCorePoolSize(2);
//队列容量
    executor.setQueueCapacity(2);
//最大线程数
    executor.setMaxPoolSize(2);
//拒绝策略
    executor.setRejectedExecutionHandler(ThreadPoolExecutor.AbortPolicy);
    return executor;
}

创建任务执行时首先判断是否大于核心线程数，超过核心线程数后，新进入的任务开始进入队列中，再大于队列数后会继续创建线程执行任务，直到大于最大线程数后就会开始执行拒绝策略。

上面代码里使用了自带的拒绝策略，总共有4种，可以看下源码比较好理解：

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);

        }

    }

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) {

        }

    }

DiscardOldestPolicy丢弃最老的任务

    public static class DiscardOldestPolicy implements RejectedExecutionHandler {


        public DiscardOldestPolicy() { }

 


        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

            if (!e.isShutdown()) {
                //线程池队列是一个LinkedBlockingQueue先进先出,poll()方法从队头出队元素

                e.getQueue().poll();

                e.execute(r);

            }

        }

    }

CallerRunsPolicy调用主线程处理

    public static class CallerRunsPolicy implements RejectedExecutionHandler {

        public CallerRunsPolicy() { }

 
         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

            if (!e.isShutdown()) {
                //直接调用run方法相当于非异步执行

                r.run();

            }

        }

    }

通过查看源码可以看到，实现拒绝策略需要实现RejectedExecutionHandler接口，然后实现rejectedExecution方法即可。该方法两个参数，第一个就是被拒绝的Runnable任务，第二个是你使用的线程池对象。

然后模拟下业务处理

@Slf4j
@Service
public class HandleService{
    @Async("myThread")
    public void handle(BusinessObject object){
        try{
      log.info("Thread[{}],start handle...");
      Thread.currentThread().sleep(20000);
      log.info("Thread[{}],finish handle");    
        }catch(Exception e){
            
        }
    }
}

开启异步处理

@EnableAsync
@SpringBootApplication
public class Main{

@Resource
HandleService handleService;

public static void main(String[] args){
    SrpingApplication.run(Main.class,args);
}

@PostConstruct
public void startAsync(){
    BusinessObject object=new Business();
    object.setBusinessKey("123456");
    object.setBusinessType("save");
    for(int i=0;i<10;i++){
        handleService.handle(object)
    }
   }
}

自定义拒绝策略

这里主要是反射拿到任务的参数。不用@Async的话自己实现Runnable接口的也可以用这种方法拿到，不过获取的属性有些差异。

@Slf4j
@Component
public class RejectHanlde implements RejectedExecutionHandler{
    @Override
    @SneakyThrows
    public void rejectedExecution(Runnable r,ThreadPoolExecutor executor){
        Field field=r.getClass().getDeclaredField("callable");
        field.setAccessible(true);
        Callable callable=(Callable)field.get(r);
        Field invocationField=callable.getClass().getDeclaredField("arg$2");
        invocationField.setAccessible(true);
        MethodInvocation invocation=(MethodInvocation)invocationField.get(callable);
        Object[] args=invocation.getArguments();
        BusinessObject object=(BusinessObject)args[0];
        log.info("拒绝策略拒绝任务:{}",new ObjectMapper().writeValueAsString(object));
        //可以用LinkedBlokingQueue的put方法阻塞入队
        //executor.getQueue().put(r);
    }
}

线程池换成自己的拒绝策略

@Configuration
public class ThreadPoolConfigs{
    @Resource
    RejectHandler handler;

    @Bean("myThread")
    public ThreadPoolTaskExecutor myThread(){
        ThreadPoolTaskExecutor executor=new ThreadPoolTaskExecutor();
        //核心线程数
        executor.setCorePoolSize(2);
        //队列容量
        executor.setQueueCapacity(2);
        //最大线程数
        executor.setMaxPoolSize(2);
        //拒绝策略
        executor.setRejectedExecutionHandler(handler);
        return executor;
    }
}