CKTIS / Java
Java-geheugenmodel: happens-before en veilige publicatie
Leer welke schrijfbewerkingen threads in Java SE 21 kunnen waarnemen, wat volatile niet garandeert en hoe double-checked locking en VarHandle-modi werken.
Versie: 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;
}Het Java-geheugenmodel (JMM) in Java SE 21 bepaalt van welke schrijfbewerkingen een door een thread gelezen waarde afkomstig mag zijn. De relatie happens-before is transitief en volgt uit de programmavolgorde binnen een thread en uit synchronisatierelaties. Het vrijgeven van een monitor gaat vooraf aan elke latere vergrendeling van diezelfde monitor; schrijven naar een volatile-veld gaat vooraf aan elke latere leesbewerking van dat veld. ‘Later’ slaat hier op de synchronisatievolgorde, niet op de kloktijd. Een aanroep van start() gaat vooraf aan de acties van de gestarte thread, en die acties gaan vooraf aan de terugkeer uit join() nadat de thread is beëindigd.
Een datarace ontstaat als twee threads dezelfde variabele benaderen, minstens één toegang een schrijfbewerking is en geen van beide bewerkingen in de happens-before-relatie aan de andere voorafgaat. Niet-deterministische planning is iets anders: ook zonder datarace kan per uitvoering een andere thread als eerste een vergrendeling verkrijgen.
Bij veilige publicatie wordt de toestand zichtbaar die is geschreven voordat een object werd gedeeld. Bij publicatie via volatile sla je de referentie pas na de constructie op, laat je this niet voortijdig ontsnappen en laat je de ontvangende thread de gepubliceerde referentie uit hetzelfde volatile-veld lezen. Je kunt ook dezelfde monitor gebruiken voor schrijven en lezen of publiceren via klasse-initialisatie. Zichtbaarheid is niet hetzelfde als atomiciteit: afzonderlijke volatile lees- en schrijfbewerkingen zijn atomair, ook voor long en double, waarvan gewone toegang helften uit verschillende schrijfbewerkingen kan opleveren. count++ blijft afzonderlijk lezen, optellen en schrijven. volatile alleen beschermt geen invariant over meerdere velden en maakt latere wijzigingen aan het gepubliceerde object niet veilig.
Bij double-checked locking lees je volatile INSTANCE en controleer je buiten synchronized op null: na initialisatie vergrendelt het snelle pad geen monitor. Lees je null, vergrendel dan altijd dezelfde monitor Main.class, lees INSTANCE opnieuw en controleer nogmaals. Alleen als het nog steeds null is, maak je het object en sla je de referentie op in INSTANCE. De vergrendeling voorkomt dubbele initialisatie; volatile publiceert het object ook voor het snelle pad.
Bij VarHandle legt plain (get/set) geen volgorde tussen threads op; op 32-bits platforms garandeert deze modus standaard geen atomaire toegang tot long en double, tenzij de fabrieksmethode anders vermeldt. Opaque (getOpaque/setOpaque) is atomair en coherent voor dezelfde variabele, maar publiceert geen andere velden. Als getAcquire de schrijfbewerking van een bijbehorende setRelease op dezelfde variabele waarneemt, worden de toegangen vóór de release geordend vóór de toegangen na de acquire; kloktijd alleen is niet voldoende. getVolatile/setVolatile voegen een totale ordening van bewerkingen in de volatile-modus toe. De gekozen modus is bepalend: get is plain, ook op een veld dat als volatile is gedeclareerd.
Voorbeelden
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]);
}
}Resultaat
same=true, values=42/42
Elke werkthread leest zelf het gewone veld `value` en slaat het resultaat op in een afzonderlijke arraypositie. De twee `join()`-aanroepen maken de resultaten zichtbaar voor `main`; ze publiceren het object niet tussen de werkthreads. De verwachte regel `same=true, values=42/42` laat niet zien welke thread het object heeft geïnitialiseerd.
Gerelateerde lessen
- Java · Les 25 · Gevorderd · Versie: 2
- Java · Les 26 · Gevorderd · Versie: 2
- Java · Les 27 · Gevorderd · Versie: 2
- Java · Les 57 · Gevorderd · Versie: 2
Bronnen
- 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)