线程池-拒绝策略

07-14 1208阅读

线程池-拒绝策略

- RejectedExecutionHandler
- - AbortPolicy
  - CallerRunsPolicy
  - DiscardPolicy
  - DiscardOldestPolicy
  - 自定义拒绝策略
    当核心线程已用尽 & 阻塞队列已满 & 超过最大线程数时，再向线程池提交任务，则会触发线程池的拒绝策略。
    
    RejectedExecutionHandler
    
    拒绝策略是由 RejectedExecutionHandler 接口定义的。
    
    Java 默认提供了四种拒绝策略。
    
    AbortPolicy
    
    中止测试。这也线程池默认的拒绝策略。当线程池无法接受一个新的任务时，会抛出一个 RejectedExecutionException 异常。这种策略会导致任务出现丢失，且会出现抛异常的特殊情况。
```
// 创建一个核心线程10个 最大线程10个 阻塞队列1个线程池
    public static final ThreadPoolExecutor THREAD_POOL_EXECUTOR =
            new ThreadPoolExecutor(10,
                    10,
                    60,
                    TimeUnit.SECONDS,
                    new ArrayBlockingQueue(1),
                    Executors.defaultThreadFactory(),
                    new ThreadPoolExecutor.AbortPolicy()
            );
    public static void main(String[] args) {
        int errorSize = 0;
        for (int i = 0; i  {
                Thread thread = Thread.currentThread();
                String name = thread.getName();
                System.out.println("name：" + name + "-" + +System.currentTimeMillis() + " Start-index-" + finalI);
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("name：" + name + "-" + System.currentTimeMillis() + " End");
            });
        }
    }
```
    这里可以看见只有11个任务（ 10 核心线程在执行，1 个在等待队列中，这个时候线程池就不能接受任务了）执行成功了，当接受12个任务的时候，这个时候抛出了 RejectedExecutionHandler 因为没有 try-catch 所以线程中断，后续的循环也不会走了。
    
    在 for 循环中加上try-catch，可以捕获到异常了，那么后续的 12-20 个任务也可以提交到线程池中，但依然会被执行拒绝策略。
```
public static void main(String[] args) {
        int errorSize = 0;
        for (int i = 0; i  {
                    Thread thread = Thread.currentThread();
                    String name = thread.getName();
                    System.out.println("name：" + name + "-" + +System.currentTimeMillis() + " Start-index-" + finalI);
                    try {
                        TimeUnit.SECONDS.sleep(3);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("name：" + name + "-" + System.currentTimeMillis() + " End");
                });
            }catch (RejectedExecutionException e){
                e.printStackTrace();
            }
        }
    }
```
    CallerRunsPolicy
    
    当任务被拒绝时，线程池会让提交任务的线程来执行这个任务。这样可以确保任务不丢失，但会让提交任务的这个线程压力很大，阻塞时间会很久。
    
    // 将拒绝策略修改为后。
    new ThreadPoolExecutor.CallerRunsPolicy()
    
    这里可以看见是 main 线程去帮我们执行了这个任务。在现在的这个情况下main线程要执行slepp(3) 9 次，会大大的降低 main 线程的执行效率
    
    
    
    DiscardPolicy
    
    丢弃任务。在线程池无法接受新任务的时候，则会执行将这个丢失掉，跳过执行。使用场景需要对任务丢失有极大的容忍度。
    
    // 将拒绝策略修改为后。
    new ThreadPoolExecutor.DiscardPolicy()
    
    只允许了 11 个任务，后续的 9 个全部丢失。
    
    DiscardOldestPolicy
    
    丢弃最旧任务。当线程池无法接收新的任务时，线程池会将阻塞队列中等待时间最久的任务给丢掉到，将新的任务加入到阻塞队中。也就是将阻塞队列头部的任务出队，再将新任务入队。这样做的目的是牺牲最老的任务以容纳最新的任务。
    
    // 将拒绝策略修改为后。
    new ThreadPoolExecutor.DiscardOldestPolicy()
    
    执行了 11 个任务，前 10 个与最后一个。这是因为 12-19 个都被拒绝策略给丢弃掉不执行了。
    
    自定义拒绝策略
    
    当 Java 提供的这四个拒绝策略你觉得不好用时，你可以自己定义这个拒绝策略来处理。也就是提供 RejectedExecutionHandler 接口的实现即可。
```
public static final ThreadPoolExecutor THREAD_POOL_EXECUTOR =
            new ThreadPoolExecutor(10,
                    10,
                    60,
                    TimeUnit.SECONDS,
                    new ArrayBlockingQueue(1),
                    Executors.defaultThreadFactory(),
                    // 使用当发生拒绝策略的时候使用forkJoinPool这个线程来执行任务
                    new RejectedExecutionHandler() {
                        @Override
                        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                            ForkJoinPool.commonPool().execute(r);
                        }
                    }
            );
```
    10 个被THREAD_POOL_EXECUTOR执行，10 个被forkJoinPool执行。
    
    当然这里不建议使用 ForkJoinPool 这种方式来处理，当大量任务会被执行拒绝策略的时候，这会导致ForkJoinPool的线程池无线扩充，最终导致内存异常等问题。这里只是举例慎用！！！！
    …(img-jERM8ZpL-1720890569610)]
    
    当然这里不建议使用 ForkJoinPool 这种方式来处理，当大量任务会被执行拒绝策略的时候，这会导致ForkJoinPool的线程池无线扩充，最终导致内存异常等问题。这里只是举例慎用！！！！