CKTIS / Java
Modelo de memoria de Java: happens-before y publicación segura
Aprende qué escrituras pueden observar otros hilos, qué garantiza volatile y cómo razonar sobre el bloqueo con doble comprobación y los modos de VarHandle en Java SE 21.
Versión: Java SE 21
Sintaxis
private static volatile Payload INSTANCE;
static Payload instance() {
Payload result = INSTANCE;
if (result == null) {
synchronized (Main.class) {
result = INSTANCE;
if (result == null) {
result = new Payload();
INSTANCE = result;
}
}
}
return result;
}En Java SE 21, el modelo de memoria de Java (JMM) determina de qué escrituras puede proceder el valor que lee un hilo. La relación happens-before es transitiva y se deriva del orden del programa dentro de un hilo y de los enlaces de sincronización. Liberar un monitor precede a toda adquisición posterior del mismo monitor; escribir un campo volatile precede a toda lectura posterior del mismo campo. Aquí, «posterior» se refiere al orden de sincronización, no al reloj. La llamada a start() precede a las acciones del hilo iniciado, y esas acciones preceden al retorno de join() tras la terminación del hilo.
Hay una carrera de datos cuando dos hilos acceden a la misma variable, al menos un acceso es una escritura y ninguno de los accesos precede al otro en la relación happens-before. La planificación no determinista es distinta: incluso sin carreras de datos, el primer hilo que adquiere un bloqueo puede variar entre ejecuciones.
La publicación segura hace visible el estado escrito antes de compartir un objeto. Para publicar mediante volatile, almacena la referencia después de construir el objeto, no dejes que this escape antes de tiempo y haz que el hilo receptor obtenga la referencia publicada leyendo el mismo campo volatile. Otras opciones son usar el mismo monitor para escribir y leer o publicar mediante la inicialización de una clase. Visibilidad no equivale a atomicidad: cada lectura o escritura volatile es atómica, incluso para long y double, cuyos accesos ordinarios pueden observar mitades de escrituras distintas. count++ sigue siendo una lectura, una suma y una escritura separadas. volatile por sí solo no protege un invariante entre varios campos ni hace seguras las modificaciones posteriores del objeto publicado.
En el bloqueo con doble comprobación, lee volatile INSTANCE y comprueba si es null fuera de synchronized: tras la inicialización, la ruta rápida no adquiere el monitor. Si lees null, adquiere siempre el mismo monitor Main.class, vuelve a leer INSTANCE y comprueba de nuevo. Solo si sigue siendo null debes construir el objeto y guardar su referencia en INSTANCE. El bloqueo evita la inicialización duplicada; volatile publica el objeto incluso para la ruta rápida.
En VarHandle, el modo plain (get/set) no impone orden entre hilos; por defecto, en plataformas de 32 bits no garantiza la atomicidad para long o double, salvo que el método de fábrica documente lo contrario. El modo opaque (getOpaque/setOpaque) ofrece acceso atómico y coherente a la misma variable, pero no publica otros campos. Si getAcquire observa la escritura del setRelease correspondiente sobre la misma variable, los accesos previos al release quedan ordenados antes de los posteriores al acquire; no basta con que haya pasado tiempo. getVolatile/setVolatile añaden un orden total entre las operaciones en modo volatile. El modo elegido manda: get es plain aunque el campo se declare volatile.
Ejemplos
public class Main {
private static volatile Payload INSTANCE;
private static final class Payload {
private int value;
private Payload() {
value = 42;
}
}
static Payload instance() {
Payload result = INSTANCE;
if (result == null) {
synchronized (Main.class) {
result = INSTANCE;
if (result == null) {
result = new Payload();
INSTANCE = result;
}
}
}
return result;
}
public static void main(String[] args) throws InterruptedException {
Payload[] references = new Payload[2];
int[] values = new int[2];
Thread first = new Thread(() -> {
Payload result = instance();
references[0] = result;
values[0] = result.value;
});
Thread second = new Thread(() -> {
Payload result = instance();
references[1] = result;
values[1] = result.value;
});
first.start();
second.start();
first.join();
second.join();
System.out.println("same=" + (references[0] == references[1])
+ ", values=" + values[0] + "/" + values[1]);
}
}Resultado
same=true, values=42/42
Cada hilo de trabajo lee por sí mismo el campo ordinario `value` y registra el resultado en una posición distinta del array. Las dos llamadas a `join()` hacen visibles los resultados para `main`; no publican el objeto entre los hilos de trabajo. La línea esperada, `same=true, values=42/42`, no revela quién inicializó el objeto.
Lecciones relacionadas
- Java · Lección 25 · Avanzado · Versión: 2
- Java · Lección 26 · Avanzado · Versión: 2
- Java · Lección 27 · Avanzado · Versión: 2
- Java · Lección 57 · Avanzado · Versión: 2
Fuentes
- Java Language Specification, Java SE 21, §17.4 — Memory Model
- Java Language Specification, Java SE 21, §17.4.5 — Happens-before Order
- Java Language Specification, Java SE 21, §17.7 — Non-Atomic Treatment of double and long
- Java Language Specification, Java SE 21, §12.4.2 — Detailed Initialization Procedure
- VarHandle (Java SE 21 & JDK 21)
- Thread (Java SE 21 & JDK 21)