mobile wallpaper 1mobile wallpaper 2mobile wallpaper 3mobile wallpaper 4
3115 words
8 minutes
并发编程二:线程池、JUC 工具与异步编程
2025-02-19
2026-09-28

商品详情接口需要查询商品、运费和推荐列表。三个查询串行执行很慢,于是把它们放进线程池。低流量时响应变快了,高峰期却开始排队、超时,甚至拖垮数据库。

线程池和异步 API 解决的是任务如何执行与协调。要让接口稳定,还需要同时回答:允许多少任务运行、队列能等多久、失败如何返回,以及调用方不等以后任务是否还在消耗资源。

本文基于 Java 21,围绕这些问题介绍线程池、Future、CompletableFuture 和常用 JUC 工具。文末有可下载实验。

1. 先把三个角色分开#

一次异步调用包含三个不同的角色:

角色负责什么
任务执行计算或 I/O
执行器分配线程、排队与拒绝
Future表示结果与完成状态

Runnable 不返回结果,Callable<T> 可以返回结果并抛出异常。ExecutorService.submit() 返回的 Future 是观察任务的入口;它不会自动让调用者不用等待。

Future<Integer> future = pool.submit(() -> calculatePrice());
int price = future.get(300, TimeUnit.MILLISECONDS);

这里的 pool 是应用管理的执行器,calculatePrice() 是业务方法。提交之后立刻 get(),调用线程仍会阻塞;如果没有同时开展其他工作,这段代码不一定比直接调用更快。

get() 的超时限制本次等待,任务本身需要独立的超时与取消策略。任务异常会通过 ExecutionException 暴露,不能提交后就把返回的 Future 丢掉。

2. 线程池如何决定创建、排队和拒绝#

使用下面这组很小的参数,便于观察行为:

AtomicInteger sequence = new AtomicInteger();
ThreadFactory factory = task -> new Thread(
task, "catalog-io-" + sequence.incrementAndGet());
ThreadPoolExecutor pool = new ThreadPoolExecutor(
2,
4,
30, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(2),
factory,
new ThreadPoolExecutor.AbortPolicy()
);

正常运行且使用可正常创建线程的工厂时,提交任务的大致顺序是:

工作线程少于 corePoolSize?
是 → 创建工作线程执行
否 → 尝试入队
入队成功 → 等待已有线程领取
队列已满 → 尝试增加线程,直到 maximumPoolSize
无法增加 → 拒绝

因此,maximumPoolSize = 4 不表示一开始就创建四个线程。默认情况下核心线程也在任务到来时按需创建;需要提前启动可以使用预启动方法。

让每个任务都阻塞在门闩上,按顺序提交 7 次,会得到:

提交次序结果
第 1、2 个创建核心线程并运行
第 3、4 个队列等待
第 5、6 个队列已满,增加线程运行
第 7 个达到上限,被拒绝

这个例子也说明:后来提交的任务可能先于队列中的任务执行,不能从“使用了队列”推导整个线程池严格按提交顺序完成。ThreadPoolExecutor API

3. 有界队列和拒绝策略应该表达业务决定#

队列存的是尚未执行的任务,也存着等待延迟。积压几万条查询,即使没有耗尽内存,轮到执行时调用者可能早已超时。

常见工厂方法各有资源模型:

  • newFixedThreadPool 使用无界队列,固定工作线程不能限制排队量。
  • newCachedThreadPool 可以不断扩展平台线程,不能直接承接无界的外部请求。
  • 显式创建 ThreadPoolExecutor,便于把并发、队列和拒绝行为写进配置。

拒绝策略不是一个“随便选”的构造参数:

策略必须接受的行为
AbortPolicy抛异常,由上层处理
CallerRunsPolicy未关闭时,提交者执行任务
DiscardPolicy静默丢弃新任务
DiscardOldestPolicy丢弃队首后再次尝试

CallerRunsPolicy 会把负载传回提交线程。如果提交线程是 HTTP 请求线程,它会被业务任务占用;如果是事件循环线程,可能阻塞整个事件循环。执行器关闭后,该策略不会继续替你执行任务。

静默丢弃与 submit() 组合还可能让调用者拿到永远不完成的 Future。对于需要明确结果的请求,通常更容易管理的是显式拒绝:返回“系统繁忙”、降级到允许缺省的数据,或进入另一个已经设计好的持久队列。只有任务已经可靠接收,才可以告诉用户“已受理”。

4. 线程数从负载预算推导,再用测量修正#

“CPU 核数加一”和“核数乘二”最多只能成为某些实验的初始值。数据库连接数、下游限流、响应时间和请求突发,都会改变实际需求。

假设某个远程查询每秒约有 200 次调用,平均占用工作线程 100 ms,则稳定负载下平均在途任务约为:

平均并发 ≈ 到达速率 × 平均停留时间
= 200 / 秒 × 0.1 秒
= 20

这是估算关系,不是直接把线程数设为 20 的结论。还需要看尾延迟、突发量、可接受排队时间,以及下游是否承受得住。

如果数据库连接池只有 10 个连接,堆出 200 个访问数据库的工作线程,大量线程只会等待连接。更合理的调试顺序是:

  1. 确定下游容量和当前接口可占用的份额。
  2. 给任务设置执行超时与最大排队等待预算。
  3. 用压测观察吞吐、P95/P99、队列等待和拒绝量。
  4. 找到资源饱和点,保留应对波动的余量。

耗时差异大、依赖不同的任务可以使用不同执行器隔离,例如报表导出不要占满支付查询使用的线程。线程池隔离之后,仍需核算它们共享的数据库总连接预算。

Java 21 的虚拟线程让大量等待型任务不必占用同样数量的平台线程,但它不会增加数据库连接或下游配额。使用虚拟线程时同样需要限制真正稀缺的资源;它们适合每个任务一个虚拟线程,无需用“少量虚拟线程池”模仿平台线程池。JEP 444

5. CompletableFuture 把依赖关系写出来#

假设商品和运费可以独立查询,两个结果共同生成页面模型。以下是组合方式示意,业务方法和 ProductPage 由应用定义:

CompletableFuture<Product> product =
CompletableFuture.supplyAsync(
() -> loadProduct(productId), ioPool);
CompletableFuture<Freight> freight =
CompletableFuture.supplyAsync(
() -> loadFreight(productId, address), ioPool);
CompletableFuture<ProductPage> page =
product.thenCombine(freight, ProductPage::new)
.orTimeout(800, TimeUnit.MILLISECONDS);

I/O 任务显式交给 ioPool,避免意外把阻塞工作放到公共池。组合函数应尽量轻量;普通 thenApply 等回调可能在完成上游的线程执行,如果回调本身很重,需要指定相应的异步执行器。

几个名字相近的方法,可按“返回值是什么”区分:

方法用途
thenApply已有值 → 新的普通值
thenCompose已有值 → 另一个异步阶段
thenCombine两个结果 → 一个组合值
allOf等待一组阶段完成

如果“拿到用户后异步查询会员权益”,查询权益返回的本来就是 Future,应使用 thenCompose,避免得到嵌套的 Future。allOf 的结果是 CompletableFuture<Void>,不会替你收集每个任务的返回值。

异常处理也要对应业务语义。推荐列表失败可以返回空列表;商品主数据失败通常不能伪装成查询成功。使用 exceptionally 返回默认值前,先明确调用方是否还能判断数据缺失。

6. 超时、取消和资源释放需要分别设计#

orTimeout 会让 Future 超时异常完成,但并不保证底层 HTTP、SQL 或计算任务停止。CompletableFuture.cancel(true) 中的参数也不能当成“必然中断底层工作”的承诺。CompletableFuture API

假设一个请求等待 800 ms 后失败,而底层查询还持续 10 秒。接下来每个请求都再发起一次查询,线程池仍然可能被这些已经无人等待的任务耗尽。

完整的等待预算应覆盖几个位置:

  • 进入执行器之前:是否已经超过请求截止时间。
  • 排队期间:任务取出时是否还有执行价值。
  • 访问下游时:客户端连接、读取或数据库查询超时。
  • 取消之后:底层是否真的停止,资源何时归还。

对有副作用的调用,还要考虑“客户端超时,但服务器已经完成”的情况。重试下单之前,需要先有业务幂等设计,不能靠 Future 状态判断订单一定没创建。

并发实验工程会让一个任务在门闩上等待,先观察 Future 超时,再放行任务。测试验证:即使 Future 已经失败,任务仍然能够继续产生效果。这比简单打印“超时了”更能说明边界。

7. 按协调需求选择 JUC 工具#

CountDownLatch:等一组动作到达终点#

适合“几个初始化任务都结束后,再开放服务”等一次性协调。计数减到 0 后不能重置;需要重复多轮协调时,考虑 CyclicBarrier 或 Phaser。

使用门闩时,必须覆盖异常和提交失败。以下示意保证每个预先登记的任务都能对应一次减计数:

CountDownLatch done = new CountDownLatch(tasks.size());
ConcurrentLinkedQueue<Throwable> failures =
new ConcurrentLinkedQueue<>();
for (Runnable task : tasks) {
try {
pool.execute(() -> {
try {
task.run();
} catch (RuntimeException e) {
failures.add(e);
} finally {
done.countDown();
}
});
} catch (RejectedExecutionException e) {
failures.add(e);
done.countDown();
}
}
boolean completed = done.await(2, TimeUnit.SECONDS);

这里假定执行器使用抛异常的拒绝策略。静默丢弃任务无法进入任何 countDown() 路径。等待结束以后,还要检查 completed 和 failures;等待超时不会自动停止任务。如果关心返回值,直接使用 Future 往往比再维护门闩和结果列表清晰。CountDownLatch API

Semaphore:限制正在使用资源的任务数#

例如限制一个实例同时访问供应商接口的调用数:

if (!supplierSlots.tryAcquire(50, TimeUnit.MILLISECONDS)) {
throw new RejectedExecutionException("供应商调用繁忙");
}
try {
return supplierClient.query();
} finally {
supplierSlots.release();
}

这是同步调用片段,supplierSlots 为共享的 Semaphore。release() 应在真实调用结束后执行;如果只是等待 Future 超时,底层调用仍在运行,就不能过早归还代表实际资源占用的许可。

信号量限制的是同时进行的数量,不是每秒请求次数。五个实例各配置 10 个许可,总体可能同时有 50 次调用;全局预算还需要额外协调。

ConcurrentHashMap:使用原子组合操作#

以下检查和写入之间仍可能插入另一个线程:

if (!cache.containsKey(key)) {
cache.put(key, value);
}

只在缺失时插入,使用 putIfAbsent;基于当前值更新计数,可以使用 merge(key, 1L, Long::sum)。

compute 系列函数应简短,避免把慢速远程调用塞进映射更新过程。容器保证也不会延伸到容器里的可变对象:并发 Map 中放一个普通 ArrayList,并不使这个列表的增删安全。ConcurrentHashMap API

8. 执行器的生命周期也属于设计#

长寿命的业务执行器应由应用统一创建和关闭,而不是每个请求创建一个池。关闭时先拒绝新任务,再给已经接收的任务一个结束窗口:

pool.shutdown();
try {
if (!pool.awaitTermination(10, TimeUnit.SECONDS)) {
var notStarted = pool.shutdownNow();
// 记录或补偿尚未执行的任务
}
} catch (InterruptedException e) {
pool.shutdownNow();
Thread.currentThread().interrupt();
}

shutdownNow() 仍然只是尝试中断;上面片段不保证所有任务最终已结束。需要持久交付的任务不能仅留在内存队列里等待优雅关闭。

排查线程池问题时,先看活跃线程、队列长度、排队时间、拒绝次数和任务耗时,再决定调参。只看 CPU 不高就继续加线程,容易错过连接等待或下游阻塞。

如果使用 Spring @Async,还要明确代理调用方式、所用执行器和异常处理,见Spring 异步任务。

9. 动手观察,而不是只背参数#

下载 Java 并发实验工程,使用 JDK 21、Maven 3.9 执行:

mvn test

12 项测试中,线程池实验固定住正在运行的任务,验证“4 个运行、2 个排队、第 7 个拒绝”;异步实验验证“Future 超时后任务仍可继续”。测试里的容量和超时专门用于展示机制,线上参数需要结合真实依赖的容量重新测量。

Share

If this article helped you, please share it with others!

并发编程二:线程池、JUC 工具与异步编程
https://mizuki.mysqil.com/posts/java-concurrency-tools/
Author
梦幻晨风
Published at
2025-02-19
License
CC BY-NC-SA 4.0

Some information may be outdated

Table of Contents