Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / Java

Memorijski model Jave: happens-before i sigurna objava

Saznaj koje zapise druge dretve mogu vidjeti u Java SE 21, što volatile ne jamči i kako rade dvostruka provjera sa zaključavanjem i načini pristupa VarHandle.

Verzija: Java SE 21

Sintaksa

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

Memorijski model Jave (JMM) u Java SE 21 određuje iz kojih zapisa može potjecati vrijednost koju dretva pročita. Relacija happens-before je tranzitivna i proizlazi iz redoslijeda programa unutar dretve te iz sinkronizacijskih veza. Otpuštanje monitora prethodi svakom kasnijem stjecanju istog monitora; upis u polje volatile prethodi svakom kasnijem čitanju istog polja. „Kasnije” se ovdje odnosi na redoslijed sinkronizacije, a ne na vrijeme na satu. Poziv start() prethodi radnjama pokrenute dretve, a te radnje prethode povratku iz join() nakon njezina završetka.

Utrka podataka nastaje kad dvije dretve pristupaju istoj varijabli, barem jedan pristup je upis, a relacija happens-before ne uređuje te pristupe. Nedeterminističko raspoređivanje nije isto: čak i bez utrke podataka, pri različitim izvršavanjima druga dretva može prva steći zaključavanje.

Sigurna objava omogućuje čitatelju da vidi stanje zapisano prije dijeljenja objekta. Pri objavi putem volatile spremi referencu nakon dovršetka konstrukcije, ne dopusti da this prerano postane dostupan i pobrini se da primateljska dretva dobije objavljenu referencu čitanjem istog polja volatile. Možeš i upotrebljavati isti monitor za upis i čitanje ili objaviti objekt inicijalizacijom klase. Vidljivost nije atomičnost: pojedinačna volatile čitanja i upisi atomični su i za long i double, čiji obični pristupi mogu vidjeti polovice iz različitih upisa. count++ i dalje zasebno čita, zbraja i zapisuje. Sam volatile ne štiti invarijantu koja obuhvaća više polja niti osigurava naknadne promjene objavljenog objekta.

U dvostrukoj provjeri sa zaključavanjem najprije pročitaj volatile INSTANCE i provjeri null izvan synchronized: nakon inicijalizacije brza putanja ne stječe monitor. Ako pročitaš null, uvijek stekni isti monitor Main.class, ponovno pročitaj INSTANCE i ponovi provjeru. Samo ako je i dalje null, stvori objekt i spremi njegovu referencu u INSTANCE. Zaključavanje sprječava dvostruku inicijalizaciju; volatile objavljuje objekt i za brzu putanju.

U VarHandle načinu plain (get/set) nema nametnutog redoslijeda među dretvama; na 32-bitnim platformama taj način zadano ne jamči atomičnost za long i double osim ako dokumentacija tvorničke metode navodi drukčije. Opaque (getOpaque/setOpaque) jamči atomičan i koherentan pristup istoj varijabli, ali ne objavljuje druga polja. Ako getAcquire opazi upis odgovarajućeg setRelease u istu varijablu, pristupi prije release uređeni su prije pristupa nakon acquire; sam protok vremena nije dovoljan. getVolatile/setVolatile dodaju potpun poredak operacija u načinu volatile. Odlučuje odabrani način: get je plain i kad je polje deklarirano kao volatile.

Primjeri

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

Rezultat

same=true, values=42/42

Svaka radna dretva sama čita obično polje `value` i sprema rezultat u zaseban element polja. Dva poziva `join()` čine rezultate vidljivima metodi `main`; ne objavljuju objekt među radnim dretvama. Očekivani redak `same=true, values=42/42` ne otkriva koja je dretva inicijalizirala objekt.

Povezane lekcije

  • Java · Lekcija 25 · Napredno · Verzija: 2
  • Java · Lekcija 26 · Napredno · Verzija: 2
  • Java · Lekcija 27 · Napredno · Verzija: 2
  • Java · Lekcija 57 · Napredno · Verzija: 2

Izvori