这个示例解决什么问题
为什么把 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 完成、被取消,或等待线程被中断。实际排查时,仅凭一次超时还看不出任务是在排队、运行,还是已经被丢弃。先核对拒绝策略和提交时的队列状态。业务需要拿到任务结果时,可以用显式拒绝让提交方马上处理失败,同时给等待结果设一个上限。关于结果等待和线程池关闭,见提交任务后怎样正确关闭。
编辑说明
历史资料未标明原作者。本页依据官方规范重新整理,并补充最小示例与验证边界,不把历史资料统一署名为本站原创。