线程池-拒绝策略

线程池-拒绝策略

• • 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的线程池无线扩充，最终导致内存异常等问题。这里只是举例慎用！！！！