Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Modello di memoria di Java: happens-before e pubblicazione sicura

Scopri quali scritture possono osservare gli altri thread in Java SE 21, cosa non garantisce volatile e come funzionano il double-checked locking e le modalità di VarHandle.

Versione: Java SE 21

Sintassi

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

In Java SE 21, il modello di memoria di Java (JMM) stabilisce da quali scritture può provenire il valore letto da un thread. La relazione happens-before è transitiva e deriva dall'ordine del programma all'interno di un thread e dai legami di sincronizzazione. Il rilascio di un monitor precede ogni acquisizione successiva dello stesso monitor; la scrittura di un campo volatile precede ogni lettura successiva dello stesso campo. Qui «successiva» è riferito all'ordine di sincronizzazione, non al tempo di orologio. La chiamata a start() precede le azioni del thread avviato, che a loro volta precedono il ritorno da join() dopo la terminazione del thread.

Si ha una corsa sui dati quando due thread accedono alla stessa variabile, almeno un accesso è una scrittura e nessuno dei due accessi precede l'altro nella relazione happens-before. La schedulazione non deterministica è un'altra cosa: anche senza corse sui dati, il primo thread ad acquisire un blocco può cambiare da un'esecuzione all'altra.

La pubblicazione sicura rende visibile lo stato scritto prima di condividere un oggetto. Per pubblicare tramite volatile, salva il riferimento dopo la costruzione, non lasciare che this sfugga in anticipo e fai ottenere al thread destinatario il riferimento pubblicato leggendo lo stesso campo volatile. Altre opzioni sono usare lo stesso monitor per scrivere e leggere oppure pubblicare tramite l'inizializzazione della classe. Visibilità e atomicità non coincidono: una singola lettura o scrittura volatile è atomica anche per long e double, i cui accessi ordinari possono osservare metà provenienti da scritture diverse. count++ rimane una sequenza di lettura, somma e scrittura. volatile da solo non protegge un invariante su più campi né rende sicure le modifiche successive all'oggetto pubblicato.

Nel double-checked locking, leggi volatile INSTANCE e verifica se è null fuori da synchronized: dopo l'inizializzazione il percorso veloce non acquisisce il monitor. Se leggi null, acquisisci sempre lo stesso monitor Main.class, rileggi INSTANCE e ripeti il controllo. Solo se è ancora null costruisci l'oggetto e ne salvi il riferimento in INSTANCE. Il blocco evita la doppia inizializzazione; volatile pubblica l'oggetto anche per il percorso veloce.

In VarHandle, plain (get/set) non impone un ordine tra thread; sulle piattaforme a 32 bit, per impostazione predefinita, non garantisce l'atomicità per long e double, salvo diversa documentazione del metodo factory. Opaque (getOpaque/setOpaque) offre accessi atomici e coerenti alla stessa variabile, ma non pubblica altri campi. Se getAcquire osserva la scrittura del corrispondente setRelease sulla stessa variabile, gli accessi prima del release sono ordinati prima di quelli dopo l'acquire: non basta che sia trascorso del tempo. getVolatile/setVolatile aggiungono un ordine totale tra le operazioni in modalità volatile. Conta la modalità scelta: get rimane plain anche per un campo dichiarato volatile.

Esempi

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

Risultato

same=true, values=42/42

Ogni thread di lavoro legge direttamente il campo ordinario `value` e salva il risultato in una posizione distinta dell'array. Le due chiamate a `join()` rendono i risultati visibili a `main`; non pubblicano l'oggetto tra i thread di lavoro. La riga attesa, `same=true, values=42/42`, non dice quale thread ha inizializzato l'oggetto.

Lezioni correlate

  • Java · Lezione 25 · Avanzato · Versione: 2
  • Java · Lezione 26 · Avanzato · Versione: 2
  • Java · Lezione 27 · Avanzato · Versione: 2
  • Java · Lezione 57 · Avanzato · Versione: 2

Fonti