Strona główna / Concurrency / Stabilne wartości
Concurrency Zaawansowany

Stabilne wartości

Bezpieczna wątkowo leniwa inicjalizacja bez volatile ani synchronized.

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

Zero boilerplate

Bez volatile, synchronized ani sprawdzeń null.

⚡

Optymalizacja JVM

JVM może zoptymalizować wartość po inicjalizacji.

🛡️

Gwarantowane jednokrotne wykonanie

Dostawca uruchamia się dokładnie raz, nawet przy rywalizacji.

Stare podejście
Podwójnie sprawdzane blokowanie
Nowoczesne podejście
StableValue
Od JDK
25
Poziom trudności
Zaawansowany
Wsparcie JDK
Stabilne wartości
Preview

Podgląd w JDK 25 (JEP 502). Wymaga --enable-preview

Jak to działa

StableValue zapewnia leniwie inicjalizowaną, niemutowalną wartość z wbudowanym bezpieczeństwem wątków. Bez podwójnie sprawdzanego blokowania, bez pól volatile, bez bloków synchronized. JVM może nawet zoptymalizować ścieżkę odczytu po inicjalizacji.

Powiązana dokumentacja
Stable Values (JEP 502) ↗ StableValue ↗
Dowód
Zobacz źródło dowodu ↗
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

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