Inicio / Concurrency / Valores con ámbito
Concurrency Avanzado

Valores con ámbito

Comparte datos a lo largo de la pila de llamadas de forma segura sin los problemas de ThreadLocal.

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

Inmutable

Los métodos invocados pueden leer pero nunca modificar el valor con ámbito.

🧹

Limpieza automática

Sin remove() manual — el valor está limitado al bloque.

⚡

Compatible con virtual threads

Funciona eficientemente con millones de virtual threads.

Enfoque Antiguo
ThreadLocal
Enfoque Moderno
ScopedValue
Desde JDK
25
Dificultad
Avanzado
Soporte JDK
Valores con ámbito
Disponible

Finalizado en JDK 25 LTS (JEP 506, sept. 2025).

Cómo funciona

ScopedValue proporciona contexto inmutable, heredable y limitado a un ámbito. A diferencia de ThreadLocal, los valores con ámbito se limpian automáticamente, funcionan con virtual threads y no pueden ser modificados por los métodos invocados.

Documentación Relacionada
Scoped Values (JEP 487) ↗ ScopedValue ↗
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

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