首页 / Concurrency / 结构化并发
Concurrency 高级

结构化并发

将并发任务的生命周期作为单个工作单元管理。

代码对比
✕ Java 8 
ExecutorService exec =
    Executors.newFixedThreadPool(2);
Future<User> u = exec.submit(this::fetchUser);
Future<Order> o = exec.submit(this::fetchOrder);
try {
    return combine(u.get(), o.get());
} finally { exec.shutdown(); }
✓ Java 25 (Preview) 
try (var scope = new StructuredTaskScope
        .ShutdownOnFailure()) {
    var u = scope.fork(this::fetchUser);
    var o = scope.fork(this::fetchOrder);
    scope.join().throwIfFailed();
    return combine(u.get(), o.get());
}
发现此代码有问题？ 告诉我们。
为什么现代方式更好
🛡️

无线程泄漏

所有分支任务在作用域关闭前完成。

🔗

错误传播

任何任务失败时取消其他任务。

📖

可读结构

并发边界在代码结构中清晰可见。

旧方式
手动线程生命周期管理
现代方式
StructuredTaskScope
自 JDK
25
难度
高级
JDK 支持
结构化并发
预览

JDK 25 预览版（第五次预览，JEP 505）。需要 --enable-preview。

工作原理

结构化并发将一组并发任务视为一个操作。如果任何任务失败，其他任务会被取消。所有分支任务在作用域关闭前完成。

相关文档
Structured Concurrency (JEP 499) ↗ StructuredTaskScope ↗
相关模式
Concurrency 入门

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    IO.println("hello");
}).join();
悬停查看现代版 ➜
JDK 21+ →
Concurrency 高级

Scoped values

Java 8
static final ThreadLocal<User> CURRENT =
    new ThreadLocal<>();
void handle(Request req) {
    CURRENT.set(authenticate(req));
    try { process(); }
    finally { CURRENT.remove(); }
}
Java 25
static final ScopedValue<User> CURRENT =
    ScopedValue.newInstance();
void handle(Request req) {
    ScopedValue.where(CURRENT,
        authenticate(req)
    ).run(this::process);
}
悬停查看现代版 ➜
JDK 25+ →
Concurrency 高级

Stable values

Java 8
private volatile Logger logger;
Logger getLogger() {
    if (logger == null) {
        synchronized (this) {
            if (logger == null)
                logger = createLogger();
        }
    }
    return logger;
}
Java 25 (Preview)
private final StableValue<Logger> logger =
    StableValue.of(this::createLogger);

Logger getLogger() {
    return logger.get();
}
悬停查看现代版 ➜
JDK 25+ →
分享 𝕏 🦋 in ⬡