Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

Paměťový model Javy: happens-before a bezpečná publikace

Zjisti, které zápisy mohou vidět jiná vlákna v Java SE 21, co nezaručuje volatile a jak fungují dvojitá kontrola se zámkem a režimy VarHandle.

Verze: Java SE 21

Syntaxe

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

Paměťový model Javy (JMM) v Java SE 21 určuje, ze kterých zápisů může pocházet hodnota přečtená vláknem. Relace happens-before je tranzitivní a vychází z pořadí programu uvnitř vlákna a ze synchronizačních vazeb. Uvolnění monitoru předchází každému pozdějšímu získání téhož monitoru; zápis do pole volatile předchází každému pozdějšímu čtení téhož pole. „Později“ tu znamená v pořadí synchronizace, nikoli podle hodin. Volání start() předchází akcím spuštěného vlákna a tyto akce předcházejí návratu z join() po jeho ukončení.

Datový závod nastává, když dvě vlákna přistupují ke stejné proměnné, alespoň jeden přístup je zápis a relace happens-before tyto přístupy neuspořádává. Nedeterministické plánování je něco jiného: i bez datového závodu může při různých spuštěních získat zámek jako první jiné vlákno.

Bezpečná publikace zpřístupní stav zapsaný před sdílením objektu. Při publikaci přes volatile ulož referenci až po dokončení konstrukce, nenech this uniknout předčasně a zajisti, aby přijímající vlákno získalo publikovanou referenci čtením téhož pole volatile. Další možností je použít stejný monitor pro zápis i čtení nebo publikovat při inicializaci třídy. Viditelnost není atomicita: jednotlivá čtení a zápisy volatile jsou atomické i pro long a double, jejichž běžné přístupy mohou pozorovat poloviny z různých zápisů. count++ zůstává posloupností čtení, přičtení a zápisu. Samotné volatile nechrání invariant zahrnující více polí ani nezajišťuje bezpečnost pozdějších změn publikovaného objektu.

Při dvojité kontrole se zámkem (double-checked locking) přečti volatile INSTANCE a zkontroluj null mimo synchronized: po inicializaci rychlá cesta monitor nezískává. Pokud přečteš null, získej vždy stejný monitor Main.class, přečti INSTANCE znovu a kontrolu zopakuj. Jen pokud je hodnota stále null, vytvoř objekt a ulož jeho referenci do INSTANCE. Zámek brání dvojí inicializaci; volatile publikuje objekt i pro rychlou cestu.

V VarHandle režim plain (get/set) nevynucuje pořadí mezi vlákny; na 32bitových platformách standardně nezaručuje atomicitu pro long a double, pokud tovární metoda nedokumentuje opak. Opaque (getOpaque/setOpaque) zajišťuje atomický a koherentní přístup ke stejné proměnné, ale nepublikuje jiná pole. Pokud getAcquire pozoruje zápis odpovídajícího setRelease do téže proměnné, jsou přístupy před release uspořádány před přístupy po acquire; samotný čas nestačí. getVolatile/setVolatile navíc zavádějí úplné uspořádání operací v režimu volatile. Rozhoduje zvolený režim: get je plain i u pole deklarovaného jako volatile.

Příklady

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

Výsledek

same=true, values=42/42

Každé pracovní vlákno samo přečte běžné pole `value` a uloží výsledek do samostatné položky pole. Dvě volání `join()` zpřístupní výsledky metodě `main`; objekt mezi pracovními vlákny nepublikují. Očekávaný řádek `same=true, values=42/42` neprozradí, které vlákno objekt inicializovalo.

Související lekce

  • Java · Lekce 25 · Pokročilá · Verze: 2
  • Java · Lekce 26 · Pokročilá · Verze: 2
  • Java · Lekce 27 · Pokročilá · Verze: 2
  • Java · Lekce 57 · Pokročilá · Verze: 2

Zdroje