Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / Java

Pomnilniški model Jave: happens-before in varna objava

Spoznaj, katere zapise lahko vidijo druge niti v Java SE 21, česa volatile ne zagotavlja ter kako delujejo dvojno preverjanje z zaklepanjem in načini VarHandle.

Različica: 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;
}

Pomnilniški model Jave (JMM) v Java SE 21 določa, iz katerih zapisov lahko izvira vrednost, ki jo prebere nit. Relacija happens-before je tranzitivna in izhaja iz vrstnega reda programa znotraj niti ter iz sinhronizacijskih povezav. Sprostitev monitorja je pred vsako poznejšo pridobitvijo istega monitorja; zapis v polje volatile je pred vsakim poznejšim branjem tega polja. »Pozneje« se tu nanaša na vrstni red sinhronizacije, ne na čas po uri. Klic start() je pred dejanji zagnane niti, njena dejanja pa pred vrnitvijo iz join() po njenem koncu.

Podatkovna tekma nastane, ko dve niti dostopata do iste spremenljivke, je vsaj en dostop zapis in relacija happens-before ne ureja teh dostopov. Nedeterministično razporejanje je nekaj drugega: tudi brez podatkovne tekme lahko ob različnih zagonih ključavnico prva pridobi druga nit.

Varna objava omogoči bralcu videti stanje, zapisano pred deljenjem objekta. Pri objavi prek volatile shrani referenco po koncu konstrukcije, ne dovoli, da this prezgodaj uide, in poskrbi, da prejemna nit dobi objavljeno referenco z branjem istega polja volatile. Drugi možnosti sta uporaba istega monitorja za zapis in branje ali objava prek inicializacije razreda. Vidnost ni isto kot atomarnost: posamezna branja in zapisi volatile so atomarni tudi za long in double, pri katerih lahko navadni dostopi opazijo polovici iz različnih zapisov. count++ še vedno ločeno bere, prišteje in zapiše. Sam volatile ne varuje invariante med več polji in ne zagotavlja varnosti poznejših sprememb objavljenega objekta.

Pri dvojnem preverjanju z zaklepanjem najprej preberi volatile INSTANCE in preveri null zunaj synchronized: po inicializaciji hitra pot ne pridobi monitorja. Če prebereš null, vedno pridobi isti monitor Main.class, znova preberi INSTANCE in ponovi preverjanje. Le če je vrednost še vedno null, ustvari objekt in shrani njegovo referenco v INSTANCE. Zaklep prepreči dvojno inicializacijo; volatile objavi objekt tudi za hitro pot.

V VarHandle način plain (get/set) ne vsiljuje vrstnega reda med nitmi; na 32-bitnih platformah privzeto ne zagotavlja atomarnosti za long in double, razen če dokumentacija tovarniške metode določa drugače. Opaque (getOpaque/setOpaque) zagotavlja atomaren in koherenten dostop do iste spremenljivke, ne objavi pa drugih polj. Če getAcquire opazi zapis ustreznega setRelease v isto spremenljivko, so dostopi pred release urejeni pred dostopi po acquire; sam čas ne zadošča. getVolatile/setVolatile dodata popolno ureditev operacij v načinu volatile. Odloča izbrani način: get je plain tudi za polje, deklarirano kot volatile.

Primeri

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

Vsaka delovna nit sama prebere navadno polje `value` in zapiše rezultat na svoje mesto v tabeli. Oba klica `join()` omogočita, da `main` vidi rezultate; objekta ne objavita med delovnima nitma. Pričakovana vrstica `same=true, values=42/42` ne pove, katera nit je objekt inicializirala.

Povezane lekcije

  • Java · Lekcija 25 · Napredna · Različica: 2
  • Java · Lekcija 26 · Napredna · Različica: 2
  • Java · Lekcija 27 · Napredna · Različica: 2
  • Java · Lekcija 57 · Napredna · Različica: 2

Viri