Inicio / Concurrency / Inicialización perezosa sin bloqueos
Concurrency Avanzado

Inicialización perezosa sin bloqueos

Reemplaza el double-checked locking con StableValue para singletons perezosos.

Comparación de Código
✕ 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();
    }
}
¿Ves un problema con este código? Cuéntanos.
Por qué gana la forma moderna
🧹

Sin código repetitivo

Sin volatile, synchronized ni double-null-check.

⚡

Lecturas más rápidas

La JVM puede plegar constantes después de la inicialización.

✅

Corrección demostrable

Sin errores sutiles de ordenamiento — la JVM se encarga.

Enfoque Antiguo
synchronized + volatile
Enfoque Moderno
StableValue
Desde JDK
25
Dificultad
Avanzado
Soporte JDK
Inicialización perezosa sin bloqueos
Preview

Preview en JDK 25 (JEP 502, StableValue). Requiere --enable-preview.

Cómo funciona

StableValue encapsula el patrón de inicialización perezosa con seguridad entre hilos correcta. La JVM puede optimizar la ruta de lectura después de la inicialización, haciéndola potencialmente más rápida que las lecturas volatile.

Documentación Relacionada
StableValue (JEP 502) ↗ StableValue ↗
Patrones relacionados
Concurrency Principiante

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    IO.println("hello");
}).join();
Pasa el ratón para ver el moderno ➜
JDK 21+ →
Concurrency Avanzado

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());
}
Pasa el ratón para ver el moderno ➜
JDK 25+ →
Concurrency Avanzado

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);
}
Pasa el ratón para ver el moderno ➜
JDK 25+ →
Compartir 𝕏 🦋 in ⬡