Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Model pamięci Javy: happens-before i bezpieczna publikacja

Model pamięci Javy określa, które zapisy mogą zobaczyć inne wątki. Poznaj relację happens-before, granice volatile, podwójne sprawdzanie z blokadą i tryby dostępu VarHandle.

Wersja: Java SE 21

Składnia

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

W Java SE 21 model pamięci Javy (JMM) określa, z których zapisów może pochodzić wartość odczytana przez wątek. Relacja happens-before wynika z kolejności programu w obrębie wątku oraz z krawędzi synchronizacji i jest przechodnia. Zwolnienie monitora poprzedza w tej relacji każde późniejsze przejęcie tego samego monitora; zapis do pola volatile — każdy późniejszy odczyt tego pola. „Późniejszy” oznacza tu kolejność synchronizacji, nie czas zegarowy. Wywołanie start() poprzedza działania uruchomionego wątku, a jego działania poprzedzają powrót z join() po jego zakończeniu.

Wyścig danych zachodzi, gdy dwa wątki odwołują się do tej samej zmiennej, co najmniej jedno z odwołań jest zapisem i relacja happens-before ich nie porządkuje. Niedeterministyczna kolejność wykonywania to nie to samo: nawet bez wyścigu danych różne wątki mogą zdobyć blokadę jako pierwsze.

Bezpieczna publikacja pozwala odbiorcy zobaczyć stan zapisany przed udostępnieniem obiektu. Przy publikacji przez volatile zapisz referencję po zakończeniu konstruktora, nie udostępniaj przedwcześnie this, a w wątku odbiorcy odczytaj to samo pole volatile i uzyskaj opublikowaną referencję. Inne możliwości to użycie tego samego monitora przy zapisie i odczycie albo publikacja przez inicjalizację klasy. Widoczność to nie atomowość: pojedyncze odczyty i zapisy volatile są atomowe, także dla long i double, których zwykłe odczyty mogą zobaczyć połówki z różnych zapisów. count++ nadal składa się z odczytu, dodawania i zapisu. volatile nie chroni samodzielnie niezmiennika obejmującego kilka pól ani późniejszych modyfikacji obiektu.

W podwójnym sprawdzaniu z blokadą (double-checked locking) pierwszy test null następuje po odczycie volatile INSTANCE, poza synchronized: po inicjalizacji szybka ścieżka nie przejmuje monitora. Jeśli odczyt da null, przejmij zawsze ten sam monitor Main.class, ponownie odczytaj INSTANCE i sprawdź null. Tylko wtedy utwórz obiekt i zapisz referencję do INSTANCE. Blokada zapobiega powtórnej inicjalizacji; volatile zapewnia publikację także dla szybkiej ścieżki.

W VarHandle tryb plain (get/set) nie wprowadza porządku między wątkami; domyślnie na platformach 32-bitowych nie gwarantuje też atomowości dla long i double, chyba że dokumentacja metody fabrykującej stanowi inaczej. Opaque (getOpaque/setOpaque) zapewnia atomowy dostęp i spójną kolejność dla tej samej zmiennej, ale nie publikuje innych pól. Jeśli getAcquire odczyta wartość zapisaną przez odpowiadające mu setRelease na tej samej zmiennej, operacje sprzed zapisu release są uporządkowane przed operacjami po odczycie acquire; sam upływ czasu nie wystarcza. getVolatile/setVolatile zapewniają też całkowity porządek operacji w trybie volatile. Liczy się wybrany tryb: get jest dostępem plain nawet do pola zadeklarowanego jako volatile.

Przykłady

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

Wynik

same=true, values=42/42

Każdy wątek roboczy sam odczytuje zwykłe pole `value` i zapisuje wynik w osobnej komórce tablicy. Oba wywołania `join()` przekazują wyniki do `main`, a nie stan obiektu między wątkami roboczymi. Oczekiwany wiersz to `same=true, values=42/42`; nie wskazuje on, który wątek utworzył obiekt.

Powiązane lekcje

  • Java · Lekcja 25 · Zaawansowany · Wersja: 2
  • Java · Lekcja 26 · Zaawansowany · Wersja: 2
  • Java · Lekcja 27 · Zaawansowany · Wersja: 2
  • Java · Lekcja 57 · Zaawansowany · Wersja: 2

Źródła