Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Metody ReentrantLock: przejmowanie blokady, ponowne wejście i warunki

Rozróżnij blokujące `lock()` i dwa warianty `tryLock()`, zbilansuj każde przejęcie przez `unlock()` i użyj dwóch warunków powiązanych z tą samą blokadą.

Wersja: Java SE 21

Składnia

// Java SE 21 — instance methods of java.util.concurrent.locks.ReentrantLock
public void lock()
public void unlock()
public boolean tryLock()
public boolean tryLock(long timeout, java.util.concurrent.TimeUnit unit) throws InterruptedException
public java.util.concurrent.locks.Condition newCondition()
public int getHoldCount()

W Java SE 21 klasa java.util.concurrent.locks.ReentrantLock zapewnia blokadę wielokrotnego wejścia. lock() czeka, jeśli blokadę posiada inny wątek, i nie przerywa tego oczekiwania po przerwaniu wątku. Właściciel może przejąć ją ponownie bez czekania. getHoldCount() zwraca liczbę niezbilansowanych przejęć przez bieżący wątek, a nie liczbę oczekujących; 0 nie oznacza, że blokada jest wolna.

unlock() zmniejsza licznik o jeden i zwalnia blokadę dopiero przy 0. Wywołanie przez wątek, który nie jest właścicielem, zgłasza IllegalMonitorStateException. Bezpośrednio po każdym udanym przejęciu wejdź do try, a odpowiadające mu unlock() umieść w finally. Nie zwalniaj blokady w imieniu nieudanej próby ani próby zakończonej wyjątkiem. Gdy kod potrzebuje obu blokad, niech wszystkie ścieżki przejmują je w tej samej kolejności, np. gateLock przed orderLock, i zwalniają w odwrotnej.

tryLock() nie czeka: zwraca false, gdy blokadę posiada inny wątek, a po udanym przejęciu, także ponownym, zwraca true. Nawet przy włączonej polityce sprawiedliwości może wyprzedzić oczekujących. tryLock(timeout, unit) respektuje tę politykę, jeśli jest włączona, czeka najwyżej przez podany czas (timeout <= 0 oznacza brak czekania) i zwraca false, jeśli nie uzyska blokady w tym czasie. Przerwanie przy wejściu lub podczas przejmowania powoduje InterruptedException i kasuje flagę przerwania; unit == null jest niedozwolone i powoduje NullPointerException.

Każde newCondition() tworzy oddzielny obiekt Condition powiązany z tą samą blokadą. W buforze na jeden element notEmpty służy odbiorcom, a notFull producentom. Wywołanie signal() bez posiadania tej blokady zgłasza IllegalMonitorStateException. await() najpierw sprawdza flagę przerwania bieżącego wątku. Jeśli flaga jest już ustawiona, await() kasuje ją i zgłasza InterruptedException przed sprawdzeniem, czy wątek posiada blokadę, i bez zwalniania blokady. Jeśli flaga nie jest ustawiona, brak blokady skutkuje IllegalMonitorStateException. Jeśli await() przechodzi do oczekiwania, atomowo zwalnia blokadę i przed zakończeniem wywołania przejmuje ją ponownie z poprzednią liczbą przejęć. Sprawdzaj stan w pętli while, bo możliwe są samoistne wybudzenia. Sygnalizuj po zmianie stanu, nadal trzymając blokadę; signal() jej nie zwalnia.

Przykłady

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Main {
    private static final class Slot {
        private final ReentrantLock lock = new ReentrantLock();
        private final Condition notEmpty = lock.newCondition();
        private final Condition notFull = lock.newCondition();
        private Integer value;

        void put(int item) throws InterruptedException {
            lock.lock();
            try {
                while (value != null) {
                    notFull.await();
                }
                value = item;
                notEmpty.signal();
            } finally {
                lock.unlock();
            }
        }

        int take() throws InterruptedException {
            lock.lock();
            try {
                while (value == null) {
                    notEmpty.await();
                }
                int item = value;
                value = null;
                notFull.signal();
                return item;
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock gateLock = new ReentrantLock();
        ReentrantLock orderLock = new ReentrantLock(true);

        System.out.println(orderLock.getHoldCount());
        orderLock.lock();
        try {
            orderLock.lock();
            try {
                System.out.println(orderLock.getHoldCount());
            } finally {
                orderLock.unlock();
            }
            System.out.println(orderLock.getHoldCount());
            if (orderLock.tryLock()) {
                try {
                    System.out.println(orderLock.getHoldCount());
                } finally {
                    orderLock.unlock();
                }
            }
            System.out.println(orderLock.getHoldCount());
        } finally {
            orderLock.unlock();
        }
        System.out.println(orderLock.getHoldCount());

        gateLock.lock();
        try {
            for (int attempt = 1; attempt <= 2; attempt++) {
                if (!orderLock.tryLock(10, TimeUnit.MILLISECONDS)) {
                    System.out.println("timed " + attempt + ": timeout");
                    continue;
                }
                try {
                    System.out.println("timed " + attempt + ": acquired");
                } finally {
                    orderLock.unlock();
                }
            }
        } finally {
            gateLock.unlock();
        }

        Slot slot = new Slot();
        slot.put(42);
        System.out.println("slot: " + slot.take());
    }
}

Wynik

0
2
1
2
1
0
timed 1: acquired
timed 2: acquired
slot: 42

Dwa wywołania `lock()` dają pierwszy odczyt `2` po początkowym `0`. Po jednym `unlock()` jest `1`, a natychmiastowe `tryLock()` właściciela ponownie daje `2`. Dwa pozostałe zwolnienia dają `1` i `0`. Obie próby czasowe dotyczą tej samej `orderLock` i kończą się sukcesem bez rywalizacji. `put(42)` i `take()` używają osobnych warunków jednej blokady bufora; w tym wykonaniu żadna operacja nie czeka.

Powiązane lekcje

  • Java · Lekcja 30 · Zaawansowany · Wersja: 2
  • Java · Lekcja 54 · Średniozaawansowany · Wersja: 2
  • Java · Lekcja 58 · Średniozaawansowany · Wersja: 2

Źródła