CKTIS / Java
Java-Speichermodell: happens-before und sichere Veröffentlichung
Das Java-Speichermodell bestimmt, welche Schreibzugriffe andere Threads sehen können. Lerne happens-before, die Grenzen von volatile, Double-Checked Locking und VarHandle-Modi kennen.
Version: Java SE 21
Syntax
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;
}Das Java-Speichermodell (JMM) in Java SE 21 legt fest, aus welchen Schreibzugriffen der gelesene Wert eines Threads stammen darf. Die Relation happens-before ist transitiv und ergibt sich aus der Programmreihenfolge im Thread und aus Synchronisationsbeziehungen. Das Freigeben eines Monitors liegt vor jedem späteren Sperren desselben Monitors; ein Schreibzugriff auf ein volatile-Feld liegt vor jedem späteren Lesezugriff auf dieses Feld. „Später“ bezieht sich hier auf die Synchronisationsreihenfolge, nicht auf die Uhrzeit. Der Aufruf von start() liegt vor den Aktionen des gestarteten Threads, und diese liegen vor der Rückkehr aus join() nach dessen Beendigung.
Ein Datenrennen liegt vor, wenn zwei Threads auf dieselbe Variable zugreifen, mindestens einer schreibt und keiner der Zugriffe in der happens-before-Relation vor dem anderen liegt. Nichtdeterministische Ablaufplanung ist etwas anderes: Auch ohne Datenrennen können in verschiedenen Läufen unterschiedliche Threads zuerst eine Sperre erhalten.
Sichere Veröffentlichung macht den vor der Weitergabe geschriebenen Zustand eines Objekts für Leser sichtbar. Bei der Veröffentlichung über volatile speicherst du die Referenz nach der Konstruktion, gibst this nicht vorzeitig weiter und lässt den empfangenden Thread die veröffentlichte Referenz aus demselben volatile-Feld lesen. Alternativ eignen sich derselbe Monitor für Schreiben und Lesen oder die Klasseninitialisierung. Sichtbarkeit ist nicht Atomarität: Einzelne volatile Lese- und Schreibzugriffe sind auch bei long und double atomar; bei gewöhnlichen Zugriffen können die Hälften aus verschiedenen Schreibzugriffen stammen. count++ bleibt eine Folge aus Lesen, Addieren und Schreiben. volatile allein schützt weder eine Invariante über mehrere Felder noch spätere Änderungen am veröffentlichten Objekt.
Beim Double-Checked Locking liest du volatile INSTANCE und prüfst zunächst außerhalb von synchronized auf null. Nach der Initialisierung sperrt der schnelle Pfad keinen Monitor. Ergibt das Lesen null, sperrst du im langsamen Pfad immer denselben Monitor Main.class, liest INSTANCE erneut und prüfst erneut. Nur wenn der Wert weiterhin null ist, erzeugst du das Objekt und speicherst seine Referenz in INSTANCE. Die Sperre verhindert eine doppelte Initialisierung; volatile stellt die Veröffentlichung auch für den schnellen Pfad sicher.
Bei VarHandle erzwingt Plain (get/set) keine Ordnung zwischen Threads; für long und double ist auf 32-Bit-Plattformen standardmäßig keine Atomarität garantiert, sofern die Fabrikmethode nichts anderes dokumentiert. Opaque (getOpaque/setOpaque) ist für dieselbe Variable atomar und kohärent, veröffentlicht aber keine anderen Felder. Liest getAcquire den Wert eines passenden setRelease auf derselben Variable, liegen die Zugriffe vor dem Release in dieser Ordnung vor den Zugriffen nach dem Acquire; die Uhrzeit allein genügt nicht. getVolatile/setVolatile bringen die Operationen im Volatile-Modus zusätzlich in eine totale Ordnung. Der Modus entscheidet: get bleibt auch bei einem als volatile deklarierten Feld ein Plain-Zugriff.
Beispiele
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]);
}
}Ergebnis
same=true, values=42/42
Jeder Worker liest das gewöhnliche Feld `value` selbst und speichert sein Ergebnis in einem eigenen Array-Element. Die beiden `join()`-Aufrufe machen die Ergebnisse für `main` sichtbar; sie veröffentlichen das Objekt nicht zwischen den Workern. Die erwartete Zeile `same=true, values=42/42` verrät nicht, welcher Worker das Objekt initialisiert hat.
Zugehörige Lektionen
- Java · Lektion 25 · Fortgeschritten · Version: 2
- Java · Lektion 26 · Fortgeschritten · Version: 2
- Java · Lektion 27 · Fortgeschritten · Version: 2
- Java · Lektion 57 · Fortgeschritten · Version: 2
Quellen
- 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)