Java 并发学习专题

ThreadPoolExecutor:线程、队列与拒绝策略怎样配合

用有界队列复现线程池扩容与任务拒绝。说明适用版本、完整示例、预期结果与验证边界。

简明结论

达到核心线程数后通常先排队,队列满了才继续创建线程;达到最大线程数且无法入队时触发拒绝策略。

这个示例解决什么问题

为什么把 maximumPoolSize 调大,任务还是一直排队?关键在提交任务时的决策顺序,而不是只看最大线程数。

条件对新任务的处理
工作线程少于 corePoolSize尝试创建线程执行任务
已达到核心线程数,队列可接收先进入队列等待
队列已满,线程数未达到 maximumPoolSize尝试增加工作线程
无法入队,也无法创建线程交给拒绝策略

这里描述正常运行时的主要规则。关闭状态、线程工厂失败等也可能导致任务被拒绝;线程数检查并不是对调用者的事务保证。

可复现:一个排队、两个执行、一个拒绝

下面使用 JDK 21 的标准库,无需第三方依赖。两个工作任务通过闩锁保持运行,避免用 sleep 猜测调度时机。

import java.util.concurrent.*;

public class BoundedPoolDemo {
  public static void main(String[] args) throws Exception {
    var release = new CountDownLatch(1);
    var started = new CountDownLatch(2);
    var firstStarted = new CountDownLatch(1);
    var pool = new ThreadPoolExecutor(1, 2, 30, TimeUnit.SECONDS,
        new ArrayBlockingQueue<>(1), new ThreadPoolExecutor.AbortPolicy());
    Runnable blocking = () -> {
      firstStarted.countDown();
      started.countDown();
      try { release.await(); }
      catch (InterruptedException e) { Thread.currentThread().interrupt(); }
    };
    boolean rejected = false;
    try {
      pool.execute(blocking);
      if (!firstStarted.await(3, TimeUnit.SECONDS)) throw new AssertionError("first worker timeout");
      pool.execute(() -> {}); // The one-slot queue is now full.
      pool.execute(blocking); // Queue full: grow to maximumPoolSize.
      if (!started.await(3, TimeUnit.SECONDS)) throw new AssertionError("worker timeout");
      try { pool.execute(() -> {}); }
      catch (RejectedExecutionException expected) { rejected = true; }
      if (!rejected || pool.getQueue().size() != 1) throw new AssertionError("pool bounds");
    } finally {
      release.countDown();
      pool.shutdown();
      if (!pool.awaitTermination(5, TimeUnit.SECONDS)) pool.shutdownNow();
    }
    System.out.println("rejected=" + rejected + "; completed=" + pool.getCompletedTaskCount());
    if (pool.getCompletedTaskCount() != 3) throw new AssertionError("completion count");
  }
}

保存为 BoundedPoolDemo.java,运行 java BoundedPoolDemo.java。

预期输出:

rejected=true; completed=3

参数选择的边界

无界队列通常会让任务在核心线程之后持续排队,maximumPoolSize 很难发挥预期作用。队列容量和线程数都要结合任务耗时、到达速率、下游连接数与延迟目标评估,不能从这段功能示例推出生产参数。

核心线程默认也不是构造时全部启动,可以预启动;允许核心线程超时后,核心线程也可能被回收。任务执行异常与提交时的拒绝是不同故障,要分别观察。

排查顺序

先看任务是否被接受,再检查活跃线程、队列长度、拒绝记录和下游耗时。示例使用 AbortPolicy 显式报告饱和;不要在不了解业务后果时静默丢弃任务。

任务被丢了,为什么 Future 还在等?

线程池满了,用 AbortPolicy 时,submit() 当场抛异常。换成 DiscardPolicy,同一个调用却能拿到 Future。这个任务已经被丢了,即使队列后来腾出了位置,线程池也不会再执行它。

下面把线程池设成一个工作线程、一个队列位置。第一项任务用闩锁占住线程,第二项填满队列,第三项用 submit() 提交。两次运行只换拒绝策略。保存为 RejectedFutureDemo.java,用 JDK 21 执行 java RejectedFutureDemo.java。

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;

public class RejectedFutureDemo {
  public static void main(String[] args) throws Exception {
    reproduce(new ThreadPoolExecutor.AbortPolicy());
    reproduce(new ThreadPoolExecutor.DiscardPolicy());
  }

  private static void reproduce(RejectedExecutionHandler policy) throws Exception {
    var started = new CountDownLatch(1);
    var release = new CountDownLatch(1);
    var ran = new AtomicBoolean();
    var pool = new ThreadPoolExecutor(1, 1, 0, TimeUnit.SECONDS,
        new ArrayBlockingQueue<>(1), policy);
    String name = policy.getClass().getSimpleName();
    Future<Integer> rejected = null;
    try {
      pool.execute(() -> {
        started.countDown();
        try {
          release.await();
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
        }
      });
      if (!started.await(5, TimeUnit.SECONDS)) throw new AssertionError("worker did not start");
      Future<Integer> queued = pool.submit(() -> 7);
      if (pool.getQueue().remainingCapacity() != 0) throw new AssertionError("queue not full");

      try {
        rejected = pool.submit(() -> {
          ran.set(true);
          return 42;
        });
        if (policy instanceof ThreadPoolExecutor.AbortPolicy) {
          throw new AssertionError("submit should throw");
        }
        System.out.println(name + ": submit returned Future, done=" + rejected.isDone());
        try {
          rejected.get(100, TimeUnit.MILLISECONDS);
          throw new AssertionError("discarded task should not return a value");
        } catch (TimeoutException expected) {
          if (rejected.isDone()) throw new AssertionError("timeout changed Future state");
          System.out.println(name + ": timed get threw TimeoutException, done=" + rejected.isDone());
        }
      } catch (RejectedExecutionException expected) {
        if (!(policy instanceof ThreadPoolExecutor.AbortPolicy)) throw expected;
        System.out.println(name + ": submit threw RejectedExecutionException");
      }

      release.countDown();
      if (queued.get(5, TimeUnit.SECONDS) != 7) throw new AssertionError("wrong queued result");
      pool.shutdown();
      if (!pool.awaitTermination(5, TimeUnit.SECONDS)) throw new AssertionError("pool still running");
      if (ran.get()) throw new AssertionError("rejected task ran");
      if (rejected != null && rejected.isDone()) throw new AssertionError("discarded Future completed");
      System.out.println(name + ": queued task returned 7, rejected task ran=" + ran.get()
          + (rejected == null ? "" : ", Future done=" + rejected.isDone()));
    } finally {
      if (rejected != null) rejected.cancel(false);
      release.countDown();
      pool.shutdownNow();
    }
  }
}

Temurin 21.0.13 实测输出如下。

AbortPolicy: submit threw RejectedExecutionException
AbortPolicy: queued task returned 7, rejected task ran=false
DiscardPolicy: submit returned Future, done=false
DiscardPolicy: timed get threw TimeoutException, done=false
DiscardPolicy: queued task returned 7, rejected task ran=false, Future done=false

两次运行里,排队的第二项任务都返回了 7,被拒绝的第三项都没执行。差别在提交这一刻。AbortPolicy 抛出 RejectedExecutionException,调用方拿不到第三项的 Future。DiscardPolicy 静默丢弃任务,submit() 仍把先前创建的 FutureTask 返回给调用方。这个对象没有被执行或取消,所以线程池已经结束了,它的 isDone() 仍是 false。 JDK 21 的 submit 实现说明 · DiscardPolicy 文档

这里用限时 get() 是为了让示例能退出。它抛出 TimeoutException 后,Future 仍未完成。如果换成不带超时的 get(),等待会持续到该 Future 完成、被取消,或等待线程被中断。实际排查时,仅凭一次超时还看不出任务是在排队、运行,还是已经被丢弃。先核对拒绝策略和提交时的队列状态。业务需要拿到任务结果时,可以用显式拒绝让提交方马上处理失败,同时给等待结果设一个上限。关于结果等待和线程池关闭,见提交任务后怎样正确关闭。

编辑说明

历史资料未标明原作者。本页依据官方规范重新整理,并补充最小示例与验证边界,不把历史资料统一署名为本站原创。