Strona główna / Concurrency / Lock-free lazy initialization
Concurrency Zaawansowany

Lock-free lazy initialization

Replace double-checked locking with StableValue for lazy singletons.

Porównanie kodu
✕ Java 8 
class Config {
    private static volatile Config inst;
    static Config get() {
        if (inst == null) {
            synchronized (Config.class) {
                if (inst == null)
                    inst = load();
            }
        }
        return inst;
    }
}
✓ Java 25 (Preview) 
class Config {
    private static final
        StableValue<Config> INST =
            StableValue.of(Config::load);

    static Config get() {
        return INST.get();
    }
}
Widzisz problem z tym kodem? Daj nam znać.
Dlaczego nowoczesne podejście wygrywa
🧹

No boilerplate

No volatile, synchronized, or double-null-check.

⚡

Faster reads

JVM can constant-fold after initialization.

✅

Provably correct

No subtle ordering bugs — the JVM handles it.

Stare podejście
synchronized + volatile
Nowoczesne podejście
StableValue
Od JDK
25
Poziom trudności
Zaawansowany
Wsparcie JDK
Lock-free lazy initialization
Preview

Preview in JDK 25 (JEP 502, StableValue). Requires --enable-preview.

Jak to działa

StableValue encapsulates the lazy initialization pattern with correct thread safety. The JVM can optimize the read path after initialization, potentially making it faster than volatile reads.

Powiązana dokumentacja
StableValue (JEP 502) ↗ StableValue ↗
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+ →
Udostępnij 𝕏 🦋 in ⬡