Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

ReadWriteLock — osobne blokady odczytu i zapisu

ReadWriteLock udostępnia powiązane blokady odczytu i zapisu: wielu czytelników może współdzielić dostęp, a zapis wymaga wyłączności. Poznaj metody readLock() i writeLock(), widoczność zmian oraz bezpieczne zwalnianie blokad.

Wersja: Java SE 21; repository runtime, production runtime not attested

Składnia

ReadWriteLock rw = new ReentrantReadWriteLock();
Lock read = rw.readLock();
Lock write = rw.writeLock();
read.lock();
try {
    // Read protected state.
} finally {
    read.unlock();
}
write.lock();
try {
    // Modify protected state.
} finally {
    write.unlock();
}

java.util.concurrent.locks.ReadWriteLock jest interfejsem pary powiązanych blokad. ReadWriteLock.readLock() zwraca Lock do odczytu, a ReadWriteLock.writeLock() — do zapisu; samo wywołanie tych metod nie przejmuje blokady. Wielu czytelników może działać równocześnie, gdy nie ma pisarza; zapis jest wyłączny.

Na zwróconym obiekcie wywołaj lock() przed sekcją chronioną, a unlock() w finally, umieszczając lock() przed try. Wszystkie dostępy do chronionego stanu muszą przestrzegać tego samego protokołu. Nie modyfikuj stanu pod blokadą odczytu. Udane przejęcie blokady odczytu zapewnia widoczność zmian opublikowanych przez wcześniejsze zwolnienie powiązanej blokady zapisu.

Typową implementacją jest ReentrantReadWriteLock. Jej domyślny tryb nie gwarantuje sprawiedliwej kolejności. Nie próbuj przejąć blokady zapisu, nadal trzymając blokadę odczytu: ta implementacja nie obsługuje takiego podnoszenia uprawnień. Po zwolnieniu odczytu i przejęciu zapisu ponownie sprawdź warunek, ponieważ stan mógł się zmienić. Te zasady implementacji nie są dodatkowymi gwarancjami interfejsu.

Rozwiązanie warto rozważyć przy częstych odczytach i rzadszych zapisach, ale narzut może zniwelować korzyści; zmierz wydajność. Przykład chroni value i deterministycznie wypisuje 42. Sekwencyjne wywołania w main pokazują użycie API, nie dowodzą równoległości ani poprawności wszystkich przeplotów wątków.

Przykłady

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Main {
    private final ReadWriteLock rw = new ReentrantReadWriteLock();
    private int value;

    public int get() {
        Lock read = rw.readLock();
        read.lock();
        try {
            return value;
        } finally {
            read.unlock();
        }
    }

    public void set(int next) {
        Lock write = rw.writeLock();
        write.lock();
        try {
            value = next;
        } finally {
            write.unlock();
        }
    }

    public static void main(String[] args) {
        Main cell = new Main();
        cell.set(42);
        System.out.println(cell.get());
    }
}

Wynik

42

Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.

Źródła