WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

volatile — Sichtbarkeit von Feldern zwischen Threads

volatile ist ein reserviertes Schlüsselwort, das ein Feld für die Kommunikation zwischen Threads kennzeichnet. Es garantiert Sichtbarkeit und eine happens-before-Reihenfolge, bietet aber weder gegenseitigen Ausschluss noch Atomarität für Operationen wie count++.

Version: Java SE 21; repository runtime, production runtime not attested

Syntax

[accessModifier] [static] volatile Type fieldName [= initializer];

volatile ist ein reserviertes Schlüsselwort in Java SE 21 und ein Modifikator für ein Instanzfeld oder ein static-Feld. Es kann keine lokalen Variablen, Parameter oder Methoden kennzeichnen. final und volatile für dasselbe Feld zu kombinieren, ist ein Kompilierungsfehler. Die eckigen Klammern in der gezeigten Syntax kennzeichnen optionale Bestandteile und sind kein wörtlicher Java-Code.

Ein Schreibzugriff auf ein volatile-Feld steht in einer happens-before-Beziehung zu jedem späteren Lesezugriff auf dasselbe Feld; „später“ bezieht sich dabei auf die Synchronisationsreihenfolge. Aufgrund der Transitivität dieser Beziehung werden frühere Schreibzugriffe des schreibenden Threads für den lesenden Thread sichtbar, nachdem dieser den entsprechenden volatile-Lesezugriff ausgeführt hat. Das bedeutet nicht, dass ein anderer Thread sofort ausgeführt wird.

volatile erwirbt keine Sperre. Einzelne Lese- und Schreibzugriffe sind zwar atomar, aber count++ umfasst einen Lesezugriff, eine Berechnung und einen Schreibzugriff. Daher können bei gleichzeitigen Erhöhungen Aktualisierungen verloren gehen. Wenn nur ein Thread in count schreibt, ist count++ weiterhin nicht atomar, aber durch einen Schreibzugriff eines anderen Threads kann keine Aktualisierung verloren gehen. Bei einem Referenzfeld gilt volatile für die Referenz, nicht automatisch für die Felder des Objekts oder die Elemente eines Arrays. Über eine einzige volatile-Referenz lässt sich dennoch eine unveränderliche Momentaufnahme veröffentlichen, die eine Invariante über mehrere Felder hinweg wahrt. Liest ein Thread die Referenz einmal und entnimmt alle relevanten Feldwerte derselben Momentaufnahme, sieht er ohne zusätzliche Synchronisierung einen konsistenten Zustand.

Im Beispiel erfolgt value = 42 vor ready = true. Sobald die Schleife true liest, muss der spätere Lesezugriff auf value den Wert 42 liefern, obwohl value nicht volatile ist. Der Aufruf von join() erfolgt erst nach der Ausgabe und stellt diese Sichtbarkeit daher nicht her. Aktives Warten verbraucht Prozessorzeit; dies ist ein Lehrbeispiel und kein standardmäßiges Warteverfahren für den Produktiveinsatz. volatile garantiert weder eine faire Zuteilung der Prozessorzeit noch eine begrenzte Wartezeit.

Beispiele

public class VolatileDemo {
    private static int value;
    private static volatile boolean ready;

    public static void main(String[] args) throws InterruptedException {
        Thread writer = new Thread(() -> {
            value = 42;
            ready = true;
        });
        writer.start();

        while (!ready) {
            // Wait for publication.
        }
        System.out.println(value);
        writer.join();
    }
}

Ergebnis

42

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen