CKTIS / Java
Metody ReentrantLock: získání zámku, opakovaný vstup a podmínky
Rozlišujte blokující `lock()` a dvě přetížení `tryLock()`, ke každému úspěšnému získání přiřaďte `unlock()` a používejte samostatné podmínky jednoho zámku.
Verze: Java SE 21
Syntaxe
// 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()V Java SE 21 je java.util.concurrent.locks.ReentrantLock reentrantní zámek pro vzájemné vyloučení. lock() čeká, pokud zámek drží jiné vlákno; přerušení vlákna toto čekání neukončí. Vlastník může tentýž zámek znovu získat bez čekání. getHoldCount() počítá dosud nevyrovnaná získání aktuálního vlákna, nikoli čekající vlákna; 0 neznamená, že je zámek volný.
unlock() sníží počítadlo o jedna a uvolní zámek až při 0. Pokud ho volá vlákno, které zámek nedrží, vyvolá IllegalMonitorStateException. Hned po každém úspěšném získání vstupte do bloku try a odpovídající unlock() umístěte do finally. Neuvolňujte zámek za pokus, který selhal nebo vyvolal výjimku. Potřebuje-li kód oba zámky, musí je na všech cestách získávat ve stejném pořadí, například gateLock před orderLock, a uvolňovat v opačném pořadí.
tryLock() nečeká: vrátí false, pokud zámek drží jiné vlákno, a true při získání včetně opakovaného vstupu. I u férového zámku může předběhnout čekající vlákna. tryLock(timeout, unit) respektuje pravidla férovosti, pokud jsou zapnutá, čeká nejvýše zadanou dobu (timeout <= 0 znamená bez čekání) a vrátí false, pokud v této době zámek nezíská. Přerušení při vstupu nebo během získávání způsobí InterruptedException a vynuluje příznak přerušení; unit == null je neplatné a způsobí NullPointerException.
Každé volání newCondition() vytvoří samostatný objekt Condition spojený s týmž zámkem. V bufferu s kapacitou jednoho prvku je notEmpty pro konzumenty a notFull pro producenty. Volání signal() bez držení tohoto zámku vyvolá IllegalMonitorStateException. Metoda await() nejprve zkontroluje příznak přerušení aktuálního vlákna. Pokud je už nastavený, vynuluje jej a vyvolá InterruptedException ještě před kontrolou, zda vlákno drží zámek, a bez uvolnění zámku. Jinak await() vyvolá IllegalMonitorStateException, pokud vlákno zámek nedrží. Pokud await() přejde do čekání, atomicky uvolní zámek a před skončením volání jej znovu získá s původním stavem počítadla. Stav ověřujte v cyklu while, protože může nastat falešné probuzení. Signalizujte po změně stavu, dokud ještě držíte zámek; signal() jej neuvolní.
Příklady
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());
}
}Výsledek
0 2 1 2 1 0 timed 1: acquired timed 2: acquired slot: 42
Dvě volání `lock()` dají po počáteční `0` první `2`. Jedno `unlock()` ponechá `1` a okamžité `tryLock()` vlastníka vrátí počítadlo na `2`. Dvě zbývající uvolnění dají `1` a `0`. Oba časově omezené pokusy míří na tentýž `orderLock` a uspějí bez soupeření vláken. `put(42)` a `take()` používají samostatné podmínky jednoho zámku bufferu; v tomto běhu ani jedna operace nečeká.
Související lekce
- Java · Lekce 30 · Pokročilá · Verze: 2
- Java · Lekce 54 · Středně pokročilá · Verze: 2
- Java · Lekce 58 · Středně pokročilá · Verze: 2