CKTIS / Java
ReentrantLock-methoden: verkrijgen, opnieuw verkrijgen en voorwaarden
Onderscheid de blokkerende `lock()` van beide `tryLock()`-overloads, koppel elke geslaagde verkrijging aan `unlock()` en gebruik aparte voorwaarden bij hetzelfde slot.
Versie: 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()In Java SE 21 is java.util.concurrent.locks.ReentrantLock een re-entrant slot voor wederzijdse uitsluiting. lock() wacht als een andere thread het slot bezit; een interrupt breekt dat wachten niet af. De eigenaar kan hetzelfde slot opnieuw verkrijgen zonder te wachten. getHoldCount() telt hoe vaak de huidige thread het slot heeft verkregen zonder die verkrijging ongedaan te maken, niet het aantal wachtende threads. 0 betekent niet dat het slot vrij is.
unlock() verlaagt de teller met één en geeft het slot pas vrij bij 0. Een thread die het slot niet bezit, krijgt IllegalMonitorStateException. Ga direct na elke geslaagde verkrijging een try-blok in en zet de bijbehorende unlock() in finally. Geef het slot niet vrij voor een mislukte poging of een poging die een uitzondering gaf. Als code beide sloten nodig heeft, moet elk pad ze in dezelfde volgorde verkrijgen, bijvoorbeeld gateLock vóór orderLock, en in omgekeerde volgorde vrijgeven.
tryLock() wacht niet: het geeft false terug als een andere thread het slot bezit en true bij verkrijging, ook als de eigenaar het opnieuw verkrijgt. Zelfs bij een eerlijk slot kan het wachtende threads passeren. tryLock(timeout, unit) respecteert het eerlijkheidsbeleid als dit aanstaat, wacht hoogstens de aangegeven tijd (timeout <= 0 betekent niet wachten) en geeft false terug als het slot niet op tijd is verkregen. Een interrupt bij binnenkomst of tijdens het verkrijgen veroorzaakt InterruptedException en wist de interruptstatus; unit == null is ongeldig en veroorzaakt NullPointerException.
Elke aanroep van newCondition() maakt een apart Condition-object dat aan hetzelfde slot is gekoppeld. In een buffer met één plek is notEmpty voor consumenten en notFull voor producenten. Wie signal() aanroept zonder dat slot te bezitten, krijgt IllegalMonitorStateException. await() controleert eerst de interruptstatus van de huidige thread. Als die status al is gezet, wist await() die en gooit het InterruptedException voordat het controleert of de thread het slot bezit, zonder het slot vrij te geven. Anders gooit await() een IllegalMonitorStateException als de thread het slot niet bezit. Als await() gaat wachten, geeft het het slot atomair vrij en verkrijgt het het slot opnieuw met de oorspronkelijke tellerstand voordat de aanroep eindigt. Controleer de toestand in een while-lus, want een thread kan onterecht ontwaken. Geef een signaal nadat de toestand is aangepast, terwijl je het slot nog bezit; signal() geeft het niet vrij.
Voorbeelden
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());
}
}Resultaat
0 2 1 2 1 0 timed 1: acquired timed 2: acquired slot: 42
Twee `lock()`-aanroepen leveren na de eerste `0` de eerste `2` op. Na één `unlock()` blijft `1` over; de onmiddellijke `tryLock()` van de eigenaar brengt de teller terug op `2`. De laatste twee vrijgaven leveren `1` en `0` op. Beide pogingen met tijdslimiet gebruiken dezelfde `orderLock` en slagen zonder concurrentie. `put(42)` en `take()` gebruiken aparte voorwaarden bij het ene bufferslot; geen van beide wacht in deze uitvoering.
Gerelateerde lessen
- Java · Les 30 · Gevorderd · Versie: 2
- Java · Les 54 · Gemiddeld · Versie: 2
- Java · Les 58 · Gemiddeld · Versie: 2