Strona główna / Concurrency / Structured concurrency
Concurrency Zaawansowany

Structured concurrency

Manage concurrent task lifetimes as a single unit of work.

Porównanie kodu
✕ 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());
}
Widzisz problem z tym kodem? Daj nam znać.
Dlaczego nowoczesne podejście wygrywa
🛡️

No thread leaks

All forked tasks complete before the scope closes.

⚡

Fast failure

ShutdownOnFailure cancels siblings if one fails.

📐

Clear structure

Task lifetime matches the lexical scope in code.

Stare podejście
Manual Thread Lifecycle
Nowoczesne podejście
StructuredTaskScope
Od JDK
25
Poziom trudności
Zaawansowany
Wsparcie JDK
Structured concurrency
Preview

Preview in JDK 25 (fifth preview, JEP 505). Requires --enable-preview.

Jak to działa

Structured concurrency treats a group of concurrent tasks as one operation. If any subtask fails, the others are cancelled. The scope ensures no thread leaks and gives clear parent-child relationships.

Powiązana dokumentacja
Structured Concurrency (JEP 499) ↗ StructuredTaskScope ↗
Powiązane wzorce
Concurrency Początkujący

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    IO.println("hello");
}).join();
Najedź, aby zobaczyć nową wersję ➜
JDK 21+ →
Concurrency Zaawansowany

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);
}
Najedź, aby zobaczyć nową wersję ➜
JDK 25+ →
Concurrency Zaawansowany

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();
}
Najedź, aby zobaczyć nową wersję ➜
JDK 25+ →
Udostępnij 𝕏 🦋 in ⬡