KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

volatile — zichtbaarheid van velden tussen threads

volatile is een gereserveerd sleutelwoord dat een veld markeert voor communicatie tussen threads. Het biedt garanties voor zichtbaarheid en happens-before-volgorde, maar geen wederzijdse uitsluiting en maakt bewerkingen zoals count++ niet atomair.

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

Syntax

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

volatile is een gereserveerd sleutelwoord in Java SE 21 en een modifier voor een instantieveld of een static-veld. Het kan niet worden gebruikt voor lokale variabelen, parameters of methoden. final en volatile combineren voor hetzelfde veld is een compilatiefout. De vierkante haken in de getoonde syntaxis geven optionele onderdelen aan, geen letterlijke Java-code.

Een schrijfoperatie naar een volatile-veld staat in een happens-before-relatie met elke latere leesoperatie van datzelfde veld; „later” verwijst naar de synchronisatievolgorde. Door de transitiviteit van deze relatie worden eerdere schrijfbewerkingen van de schrijvende thread zichtbaar voor de lezende thread na de bijbehorende volatile-leesbewerking. Dit belooft niet dat een andere thread meteen wordt uitgevoerd.

volatile vergrendelt niets. Afzonderlijke lees- en schrijfbewerkingen zijn wel atomair, maar count++ combineert een leesbewerking, een berekening en een schrijfoperatie. Daardoor kunnen bij gelijktijdige verhogingen updates verloren gaan. Als slechts één thread naar count schrijft, is count++ nog steeds niet atomair, maar kan er geen update verloren gaan door een schrijfbewerking van een andere thread. Bij een referentieveld geldt volatile voor de referentie, niet automatisch voor de velden van het object of de elementen van een array. Via één volatile-referentie kun je wel een onveranderlijke momentopname publiceren die een invariant over meerdere velden in stand houdt. Een thread die de referentie één keer leest en alle relevante veldwaarden uit diezelfde momentopname haalt, ziet zonder aanvullende synchronisatie een consistente toestand.

In het voorbeeld komt value = 42 vóór ready = true. Zodra de lus true leest, moet de latere leesbewerking van value 42 opleveren, hoewel value niet volatile is. De aanroep van join() vindt pas na het afdrukken plaats en zorgt dus niet voor deze zichtbaarheid. Actief wachten kost processortijd; dit is een didactisch voorbeeld en geen standaard-wachtpatroon voor productie. volatile garandeert noch een eerlijke verdeling van processortijd, noch een begrensde wachttijd.

Voorbeelden

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();
    }
}

Resultaat

42

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen