CKTIS / Java
Metódy ReentrantLock: získanie zámku, opakovaný vstup a podmienky
Rozlíšte blokujúce `lock()` a dve preťaženia `tryLock()`, ku každému úspešnému získaniu priraďte `unlock()` a používajte samostatné podmienky jedného zámku.
Verzia: Java SE 21
Syntax
// 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ámok na vzájomné vylúčenie. lock() čaká, ak zámok drží iné vlákno; prerušenie vlákna toto čakanie neukončí. Vlastník môže ten istý zámok získať znova bez čakania. getHoldCount() počíta doteraz nevyvážené získania aktuálneho vlákna, nie čakajúce vlákna; 0 neznamená, že je zámok voľný.
unlock() zníži počítadlo o jeden a uvoľní zámok až pri 0. Ak ho volá vlákno, ktoré zámok nedrží, vyvolá IllegalMonitorStateException. Hneď po každom úspešnom získaní vstúpte do bloku try a zodpovedajúce unlock() vložte do finally. Neuvoľňujte zámok za pokus, ktorý zlyhal alebo vyvolal výnimku. Keď kód potrebuje oba zámky, získavajte ich na každej ceste v rovnakom poradí, napríklad gateLock pred orderLock, a uvoľňujte ich v opačnom poradí.
tryLock() nečaká: vráti false, ak zámok drží iné vlákno, a true pri získaní vrátane opakovaného vstupu. Aj pri férovom zámku môže predbehnúť čakajúce vlákna. tryLock(timeout, unit) rešpektuje pravidlá férovosti, ak sú zapnuté, čaká najviac zadaný čas (timeout <= 0 znamená bez čakania) a vráti false, ak v tomto čase zámok nezíska. Prerušenie pri vstupe alebo počas získavania spôsobí InterruptedException a vymaže príznak prerušenia; unit == null je neplatné a spôsobí NullPointerException.
Každé volanie newCondition() vytvorí samostatný objekt Condition viazaný na ten istý zámok. V jednoprvkovej vyrovnávacej pamäti je notEmpty pre spotrebiteľov a notFull pre producentov. Volanie signal() bez držania zámku vyvolá IllegalMonitorStateException. Metóda await() najprv skontroluje príznak prerušenia aktuálneho vlákna. Ak je už nastavený, vymaže ho a vyvolá InterruptedException ešte pred kontrolou, či vlákno drží zámok, a bez uvoľnenia zámku. Inak await() vyvolá IllegalMonitorStateException, ak vlákno zámok nedrží. Ak await() prejde do čakania, atomicky uvoľní zámok a pred skončením volania ho znova získa s pôvodnou hodnotou počítadla. Stav kontrolujte v cykle while, pretože môže dôjsť k falošnému prebudeniu. Signalizujte po zmene stavu, kým ešte držíte zámok; signal() ho neuvoľní.
Prí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ýsledok
0 2 1 2 1 0 timed 1: acquired timed 2: acquired slot: 42
Dve volania `lock()` dajú po úvodnej `0` prvú `2`. Jedno `unlock()` ponechá `1` a okamžité `tryLock()` vlastníka vráti počítadlo na `2`. Dve zostávajúce uvoľnenia dajú `1` a `0`. Oba časovo obmedzené pokusy používajú ten istý `orderLock` a uspejú bez súperenia vlákien. `put(42)` a `take()` používajú samostatné podmienky jedného zámku vyrovnávacej pamäte; pri tomto spustení ani jedna operácia nečaká.
Súvisiace lekcie
- Java · Lekcia 30 · Pokročilá · Verzia: 2
- Java · Lekcia 54 · Stredne pokročilá · Verzia: 2
- Java · Lekcia 58 · Stredne pokročilá · Verzia: 2