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