Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Blokada odczytu i zapisu: readLock(), writeLock(), lock() i unlock()

Kilka wątków może jednocześnie czytać wspólne dane, ale zapis wymaga wyłącznego dostępu. Sam wybór blokady nie oznacza jeszcze jej przejęcia.

Wersja: Java SE 21

Składnia

// java.util.concurrent.locks.ReadWriteLock
Lock readLock();
Lock writeLock();

// java.util.concurrent.locks.Lock
void lock();
void unlock();

W Java SE 21 interfejsy ReadWriteLock i Lock należą do pakietu java.util.concurrent.locks. Metody readLock() i writeLock() zwracają powiązane obiekty Lock, ale nie przejmują blokad. Używaj jednej wspólnej instancji ReadWriteLock dla danego stanu: blokady odczytu do operacji bez zmian, a blokady zapisu do modyfikacji. Kilka wątków może jednocześnie trzymać blokadę odczytu. Gdy wątek trzyma blokadę zapisu, żaden inny wątek nie może przejąć żadnej z tych dwóch blokad.

Metody lock() i unlock() nie przyjmują argumentów i mają typ zwracany void. Wywołaj lock() przed blokiem try: jeśli blokada jest niedostępna, wątek czeka na jej przejęcie. W finally wywołaj unlock() na tym samym obiekcie Lock, by zwolnić blokadę nawet po wyjątku w chronionym kodzie. W przykładzie bezargumentowe tryLock() nie czeka: zwraca true, jeśli przejęło blokadę, albo false, jeśli jej nie przejęło. Zwalniaj blokadę tylko po udanym przejęciu.

Po zwolnieniu blokady zapisu wątek, który później skutecznie przejmie powiązaną blokadę odczytu, zobaczy zmiany wprowadzone pod blokadą zapisu. Blokady nie chronią dostępu do danych, jeśli kod je omija.

W ReentrantReadWriteLock wątek musi zrównoważyć każde przejęcie jednym unlock(); zwolnienie blokady, której wątek nie trzyma, zgłasza IllegalMonitorStateException. Mając tylko blokadę odczytu, nie próbuj przejmować blokady zapisu: lock() nie wróci. Zwolnij odczyt, przejmij zapis i ponownie sprawdź stan, bo w międzyczasie mógł się zmienić. W odwrotnym kierunku można najpierw przejąć blokadę odczytu, trzymając blokadę zapisu, a potem zwolnić zapis.

Przykłady

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

public class ReadWriteLockDemo {
    private final ReadWriteLock rw = new ReentrantReadWriteLock();
    private final Lock read = rw.readLock();
    private final Lock write = rw.writeLock();
    private int value = 0;

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        new ReadWriteLockDemo().run();
    }

    private void run() throws InterruptedException, ExecutionException {
        read.lock();
        try {
            System.out.println("read lock held: " + probeFromAnotherThread());
        } finally {
            read.unlock();
        }

        write.lock();
        try {
            value = 10;
            System.out.println("write lock held: " + probeFromAnotherThread());
        } finally {
            write.unlock();
        }

        int snapshot;
        read.lock();
        try {
            snapshot = value;
        } finally {
            read.unlock();
        }
        System.out.println("read after write: " + snapshot);
    }

    private String probeFromAnotherThread() throws InterruptedException, ExecutionException {
        FutureTask<String> probe = new FutureTask<>(() -> {
            String snapshot = "blocked";
            if (read.tryLock()) {
                try {
                    snapshot = Integer.toString(value);
                } finally {
                    read.unlock();
                }
            }
            return "reader=" + snapshot + ", writer=" + canAcquireNow(write);
        });
        new Thread(probe).start();
        return probe.get();
    }

    private static boolean canAcquireNow(Lock lock) {
        if (!lock.tryLock()) {
            return false;
        }
        try {
            return true;
        } finally {
            lock.unlock();
        }
    }
}

Wynik

read lock held: reader=0, writer=false
write lock held: reader=blocked, writer=false
read after write: 10

Gdy główny wątek trzyma blokadę odczytu, drugi wątek odczytuje `0`, ale nie może przejąć blokady zapisu. Po ustawieniu `10`, gdy główny wątek wciąż trzyma blokadę zapisu, obie próby drugiego wątku kończą się niepowodzeniem. Po zwolnieniu blokady zapisu odczyt pod blokadą daje `10`. `FutureTask.get()` utrzymuje tę kolejność bez usypiania wątków.

Powiązane lekcje

  • Java · Lekcja 29 · Zaawansowany · Wersja: 2

Źródła