Java 并发学习专题

Java 线程池:提交任务后怎样正确关闭

用 JDK 21 的完整程序观察 submit、Future.get、shutdown 和 awaitTermination,区分停止接单、任务完成与线程池终止。

简明结论

shutdown 停止接收新任务,已提交任务仍可执行;等待结果用 Future,等待线程池终止用 awaitTermination。

线程池提交成功后,调用 shutdown() 会不会把正在运行的任务杀掉?不会。下面用两个有返回值的任务观察关闭后的行为,避免把“停止接单”误当作“所有任务已经结束”。

先区分三个角色

Executor 接收任务;ExecutorService 增加任务结果和生命周期管理;ThreadPoolExecutor 允许明确设置线程数、队列和拒绝策略。本例使用有界队列,任务总数只有两个,目的在于观察关闭语义,不提供通用生产线程数。

可复现程序

保存为 ExecutorLifecycle.java,使用 JDK 21 执行 java ExecutorLifecycle.java。无需外部依赖。

import java.util.concurrent.*;

public class ExecutorLifecycle {
  public static void main(String[] args) throws Exception {
    ExecutorService pool = new ThreadPoolExecutor(1, 1, 0, TimeUnit.SECONDS,
        new ArrayBlockingQueue<>(2), new ThreadPoolExecutor.AbortPolicy());
    try {
      Future<Integer> a = pool.submit(() -> 21);
      Future<Integer> b = pool.submit(() -> 21);
      pool.shutdown();
      System.out.println("sum=" + (a.get() + b.get()));
      if (!pool.awaitTermination(5, TimeUnit.SECONDS)) throw new AssertionError("not terminated");
      System.out.println("terminated=" + pool.isTerminated());
      try {
        pool.submit(() -> 1);
        throw new AssertionError("accepted after shutdown");
      } catch (RejectedExecutionException expected) {
        System.out.println("rejected-after-shutdown=true");
      }
    } finally {
      pool.shutdownNow();
    }
  }
}

预期输出:

sum=42
terminated=true
rejected-after-shutdown=true

Future.get() 等待任务结果,也可能报告任务异常或调用线程中断。shutdown() 本身不等待执行结束,因此随后通过 awaitTermination 检查终止。最后的 submit 被拒绝,证明关闭后停止接单。

关闭失败时检查什么

如果等待超时,检查任务是否阻塞在网络、锁或下游队列。shutdownNow() 尝试中断运行任务,并返回尚未开始的任务;任务需要配合中断,不能据此宣称已强制终止。关闭等待的线程被中断时,生产代码还应恢复中断状态并按业务处理未完成任务。

本次隔离验证只覆盖两个正常任务和关闭后拒绝提交,没有模拟不响应中断的业务、资源耗尽或吞吐量。JDK 21 的虚拟线程有不同使用方式,本例讨论平台线程池;旧资料中的固定“最大线程数”或每线程内存数字不能直接套用。

虚拟线程在 synchronized 内等待会卡住谁?

把任务换成虚拟线程后,一个任务在 synchronized 内等待,另一个完全不用这把锁的任务也可能迟迟开始。下面用同一份程序在 Temurin 21.0.13 和 25.0.5.1 上对照这个现象。

实验把调度并行度和最大载体线程数都设为 1。平台线程 main 收到 A 的就绪信号后才启动 B。A 用门闩等待 B,最多等两秒。B 只打印 B.ran 并放行门闩。两组只改 A 等门闩的位置,inside 在持锁时等,outside 离开同步块再等。程序单独记录 jdk.VirtualThreadPinned 事件,阈值设为 1 毫秒。每个用例在独立 JVM 中运行,两轮的先后顺序和事件计数一致。

JDK等待位置原始运行顺序JFR 钉住事件
21.0.13锁内A 超时,随后 B 运行1
21.0.13锁外B 运行,随后 A 收到信号0
25.0.5.1锁内B 运行,随后 A 收到信号0
25.0.5.1锁外B 运行,随后 A 收到信号0

JDK 21 的锁内用例里,JFR 栈从 CountDownLatch.await 一直追到 VirtualThread.parkOnCarrierThread。A 等待时占住了唯一载体,B 要等 A 超时后才有载体可用。从 JDK 24 起,JEP 491 改变了这条路径。JDK 25 的锁内用例中,A 阻塞时可卸载,B 因此能借用这个载体运行。同步块的互斥仍然有效,B 能继续是因为它完全不用该监视器。涉及原生方法或外部函数的场景仍可能发生钉住。单载体和两秒超时是复现条件,表中结果用于判断本实验的线程调度顺序。JDK 21 虚拟线程指南 · JDK 24 的 JEP 491 变更 · JDK 25 虚拟线程指南

在一个单独目录把下面的源码保存为 PinningDemo.java,然后运行复现命令。拉取镜像后,容器以 --network none 运行。每组的 JFR 文件会保存到对应 JDK 的 results 子目录里,A.await.signalled=false 表示等到超时。

docker pull eclipse-temurin:21-jdk
docker pull eclipse-temurin:25-jdk

for jdk in 21 25; do
  mkdir -p "$PWD/results/$jdk"
  docker run --rm --pull=never --network none --cpus 2 --memory 1g \
    --mount "type=bind,source=$PWD/PinningDemo.java,target=/src/PinningDemo.java,readonly" \
    --mount "type=bind,source=$PWD/results/$jdk,target=/out" \
    -w /out "eclipse-temurin:$jdk-jdk" sh -ec '
      java -version
      for mode in inside outside; do
        java -Djdk.virtualThreadScheduler.parallelism=1 \
          -Djdk.virtualThreadScheduler.maxPoolSize=1 \
          /src/PinningDemo.java "$mode" "$mode.jfr"
        jfr print --events jdk.VirtualThreadPinned --stack-depth 32 "$mode.jfr"
      done
    '
done
完整复现代码 PinningDemo.java
import java.nio.file.Path;
import java.time.Duration;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import jdk.jfr.Recording;
import jdk.jfr.consumer.RecordingFile;

public class PinningDemo {
    public static void main(String[] args) throws Exception {
        String mode = args[0];
        if (!mode.equals("inside") && !mode.equals("outside")) {
            throw new IllegalArgumentException("mode must be inside or outside");
        }
        boolean inside = mode.equals("inside");
        Path file = Path.of(args[1]);
        Object monitor = new Object();
        CountDownLatch ready = new CountDownLatch(1);
        CountDownLatch signal = new CountDownLatch(1);

        System.out.printf("jdk=%s mode=%s parallelism=%s maxPoolSize=%s%n",
                Runtime.version(), mode,
                System.getProperty("jdk.virtualThreadScheduler.parallelism"),
                System.getProperty("jdk.virtualThreadScheduler.maxPoolSize"));

        try (Recording recording = new Recording()) {
            recording.enable("jdk.VirtualThreadPinned")
                    .withThreshold(Duration.ofMillis(1))
                    .withStackTrace();
            recording.start();
            Thread a = Thread.ofVirtual().name("A").start(() -> {
                synchronized (monitor) {
                    System.out.println("A.acquired-monitor");
                    if (inside) waitForB(ready, signal);
                }
                if (!inside) waitForB(ready, signal);
            });
            if (!ready.await(8, TimeUnit.SECONDS)) {
                throw new IllegalStateException("A did not start waiting");
            }
            Thread b = Thread.ofVirtual().name("B").start(() -> {
                System.out.println("B.ran");
                signal.countDown();
            });
            if (!a.join(Duration.ofSeconds(8)) || !b.join(Duration.ofSeconds(8))) {
                throw new IllegalStateException("virtual threads did not finish");
            }
            recording.stop();
            recording.dump(file);
        }

        long pinned = RecordingFile.readAllEvents(file).stream()
                .filter(event -> event.getEventType().getName().equals("jdk.VirtualThreadPinned"))
                .count();
        System.out.println("jdk.VirtualThreadPinned.count=" + pinned);
    }

    private static void waitForB(CountDownLatch ready, CountDownLatch signal) {
        System.out.println("A.await.begin");
        ready.countDown();
        try {
            System.out.printf("A.await.signalled=%s%n", signal.await(2, TimeUnit.SECONDS));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new IllegalStateException(e);
        }
    }
}
四组原始日志和 JFR 栈
openjdk version "21.0.13" 2026-10-20 LTS
OpenJDK Runtime Environment Temurin-21.0.13+9 (build 21.0.13+9-LTS)
OpenJDK 64-Bit Server VM Temurin-21.0.13+9 (build 21.0.13+9-LTS, mixed mode, sharing)
jdk=21.0.13+9-LTS mode=inside parallelism=1 maxPoolSize=1
A.acquired-monitor
A.await.begin
A.await.signalled=false
B.ran
jdk.VirtualThreadPinned.count=1
jdk.VirtualThreadPinned {
  startTime = 05:00:29.140 (2026-11-21)
  duration = 2.00 s
  eventThread = "A" (javaThreadId = 16, virtual)
  stackTrace = [
    java.lang.VirtualThread.parkOnCarrierThread(boolean, long) line: 689
    java.lang.VirtualThread.parkNanos(long) line: 648
    java.lang.System$2.parkVirtualThread(long) line: 2653
    jdk.internal.misc.VirtualThreads.park(long) line: 67
    java.util.concurrent.locks.LockSupport.parkNanos(Object, long) line: 267
    java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer$Node, int, boolean, boolean, boolean, long) line: 790
    java.util.concurrent.locks.AbstractQueuedSynchronizer.tryAcquireSharedNanos(int, long) line: 1160
    java.util.concurrent.CountDownLatch.await(long, TimeUnit) line: 276
    PinningDemo.waitForB(CountDownLatch, CountDownLatch) line: 61
    PinningDemo.lambda$main$0(Object, boolean, CountDownLatch, CountDownLatch) line: 33
    java.lang.VirtualThread.run(Runnable) line: 329
    jdk.internal.vm.Continuation.enterSpecial(Continuation, boolean, boolean)
  ]
}

jdk=21.0.13+9-LTS mode=outside parallelism=1 maxPoolSize=1
A.acquired-monitor
A.await.begin
B.ran
A.await.signalled=true
jdk.VirtualThreadPinned.count=0
openjdk version "25.0.5.1" 2026-11-17 LTS
OpenJDK Runtime Environment Temurin-25.0.5.1+2 (build 25.0.5.1+2-LTS)
OpenJDK 64-Bit Server VM Temurin-25.0.5.1+2 (build 25.0.5.1+2-LTS, mixed mode, sharing)
jdk=25.0.5.1+2-LTS mode=inside parallelism=1 maxPoolSize=1
A.acquired-monitor
A.await.begin
B.ran
A.await.signalled=true
jdk.VirtualThreadPinned.count=0
jdk=25.0.5.1+2-LTS mode=outside parallelism=1 maxPoolSize=1
A.acquired-monitor
A.await.begin
B.ran
A.await.signalled=true
jdk.VirtualThreadPinned.count=0

继续阅读 synchronized 与 volatile 和 Java 并发专题。

来源与继续学习

历史资料原作者和原始链接尚未确认;本页生命周期示例与边界说明由本站新增,依据下方 JDK 21 API 校对。

继续阅读线程池排队、扩容与拒绝策略,再检查ThreadLocal 的任务清理。