CKTIS / Java
Metode ReentrantLock: pridobivanje zaklepa, ponovni vstop in pogoji
Loči blokirajoči `lock()` od obeh različic `tryLock()`, vsako uspešno pridobitev uravnoteži z `unlock()` in uporabi ločene pogoje na istem zaklepu.
Različica: Java SE 21
Sintaksa
// 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 zaklep za vzajemno izključevanje, ki omogoča ponovni vstop. lock() čaka, če zaklep drži druga nit; prekinitev niti tega čakanja ne konča. Lastnik lahko isti zaklep ponovno pridobi brez čakanja. getHoldCount() šteje pridobitve trenutne niti, ki še niso bile uravnotežene s sprostitvijo, ne pa čakajočih niti; 0 ne pomeni, da je zaklep prost.
unlock() zmanjša števec za ena in sprosti zaklep šele pri 0. Nit, ki zaklepa ne drži, dobi izjemo IllegalMonitorStateException. Takoj po vsaki uspešni pridobitvi vstopi v blok try in pripadajoči unlock() postavi v finally. Zaklepa ne sproščaj za neuspešen poskus ali poskus, ki je sprožil izjemo. Kadar koda potrebuje oba zaklepa, naj ju na vseh poteh pridobi v istem vrstnem redu, na primer gateLock pred orderLock, in sprosti v obratnem vrstnem redu.
tryLock() ne čaka: vrne false, če zaklep drži druga nit, oziroma true ob pridobitvi, tudi pri ponovnem vstopu. Čakajoče niti lahko prehiti celo pri pravičnem zaklepu. tryLock(timeout, unit) upošteva pravilo pravičnosti, če je vklopljeno, čaka največ navedeni čas (timeout <= 0 pomeni brez čakanja) in vrne false, če v tem času zaklepa ne pridobi. Prekinitev ob vstopu ali med pridobivanjem sproži InterruptedException in počisti zastavico prekinitve; unit == null ni veljavno in sproži NullPointerException.
Vsak klic newCondition() ustvari ločen objekt Condition, vezan na isti zaklep. V medpomnilniku z enim mestom je notEmpty namenjen odjemalcem, notFull pa proizvajalcem. Klic signal() brez lastništva zaklepa sproži IllegalMonitorStateException. await() najprej preveri zastavico prekinitve trenutne niti. Če je že nastavljena, jo počisti in sproži InterruptedException, še preden preveri, ali nit drži zaklep, ne da bi ga sprostil. Sicer await() sproži IllegalMonitorStateException, če nit zaklepa ne drži. Če await() preide v čakanje, atomsko sprosti zaklep in ga pred koncem klica ponovno pridobi s prvotno vrednostjo števca. Stanje preverjaj v zanki while, saj je možno lažno prebujanje. Signal pošlji po spremembi stanja, ko zaklep še držiš; signal() ga ne sprosti.
Primeri
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());
}
}Rezultat
0 2 1 2 1 0 timed 1: acquired timed 2: acquired slot: 42
Dva klica `lock()` dasta prvo `2` za začetno `0`. En `unlock()` pusti `1`, takojšnji `tryLock()` lastnika pa števec vrne na `2`. Preostali sprostitvi dasta `1` in `0`. Oba časovno omejena poskusa uporabita isti `orderLock` in uspeta brez tekmovanja niti. `put(42)` in `take()` uporabljata ločena pogoja enega zaklepa medpomnilnika; pri tej izvedbi nobena operacija ne čaka.
Povezane lekcije
- Java · Lekcija 30 · Napredna · Različica: 2
- Java · Lekcija 54 · Srednja · Različica: 2
- Java · Lekcija 58 · Srednja · Različica: 2