Home / Concurrency / Lock-free lazy initialization
Concurrency advanced

Lock-free lazy initialization

Replace double-checked locking with StableValue for lazy singletons.

Code Comparison
✕ 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();
    }
}
Why the modern way wins
🧹

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.

Old Approach
synchronized + volatile
Modern Approach
StableValue
Since JDK
25
Difficulty
advanced
JDK Support
Lock-free lazy initialization
Preview

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

How it works

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.

Related Documentation
StableValue (JEP 502) ↗ StableValue ↗
Related patterns
Concurrency beginner

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    System.out.println("hello");
}).join();
Hover to see modern ➜
JDK 21+ →
Concurrency advanced

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());
}
Hover to see modern ➜
JDK 25+ →
Concurrency advanced

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);
}
Hover to see modern ➜
JDK 25+ →
Share 𝕏 🦋 in ⬡