CKTIS / Java
Metodi di ReentrantLock: acquisizione, rientro e condizioni
Distingui il metodo bloccante `lock()` dalle due forme di `tryLock()`, abbina ogni acquisizione riuscita a `unlock()` e usa condizioni distinte sullo stesso lock.
Versione: Java SE 21
Sintassi
// 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, java.util.concurrent.locks.ReentrantLock è un lock rientrante per la mutua esclusione. lock() attende se un altro thread detiene il lock; un’interruzione non annulla l’attesa. Il proprietario può acquisire di nuovo lo stesso lock senza attendere. getHoldCount() conta le acquisizioni non ancora bilanciate del thread corrente, non i thread in attesa; 0 non significa che il lock sia libero.
unlock() decrementa il contatore e rilascia il lock solo quando arriva a 0. Se il thread non detiene il lock, viene lanciata IllegalMonitorStateException. Entra in un blocco try subito dopo ogni acquisizione riuscita e inserisci il corrispondente unlock() in finally. Non rilasciare il lock per un tentativo fallito o terminato con un’eccezione. Se il codice richiede entrambi i lock, acquisiscili sempre nello stesso ordine, ad esempio gateLock prima di orderLock, e rilasciali nell’ordine inverso.
tryLock() non attende: restituisce false se un altro thread detiene il lock e true se lo acquisisce, anche in caso di rientro. Può scavalcare i thread in coda anche su un lock equo. tryLock(timeout, unit) rispetta la politica di equità se attivata, attende al massimo per il tempo indicato (timeout <= 0 significa nessuna attesa) e restituisce false se non acquisisce il lock entro quel tempo. Un’interruzione all’ingresso o durante l’acquisizione provoca InterruptedException e azzera lo stato di interruzione; unit == null non è valido e provoca NullPointerException.
Ogni chiamata a newCondition() crea un oggetto Condition distinto legato allo stesso lock. In un buffer da un elemento, notEmpty serve ai consumatori e notFull ai produttori. Chiamare signal() senza detenere quel lock provoca IllegalMonitorStateException. await() controlla prima lo stato di interruzione del thread corrente. Se il thread è già interrotto, await() azzera tale stato e lancia InterruptedException prima di verificare se il thread detiene il lock e senza rilasciarlo. Altrimenti, await() lancia IllegalMonitorStateException se il thread non detiene il lock. Se passa all’attesa, await() rilascia atomicamente il lock e lo riacquisisce con il contatore originale prima che la chiamata termini. Verifica lo stato in un ciclo while, perché sono possibili risvegli spuri. Invia il segnale dopo aver cambiato lo stato, senza rilasciare il lock; signal() non lo rilascia.
Esempi
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());
}
}Risultato
0 2 1 2 1 0 timed 1: acquired timed 2: acquired slot: 42
Due chiamate a `lock()` danno il primo `2` dopo lo `0` iniziale. Un `unlock()` lascia `1` e il `tryLock()` immediato del proprietario riporta il contatore a `2`. I due rilasci rimanenti danno `1` e `0`. Entrambi i tentativi a tempo usano lo stesso `orderLock` e riescono senza contesa. `put(42)` e `take()` usano condizioni distinte sull’unico lock del buffer; in questa esecuzione nessuna operazione attende.
Lezioni correlate
- Java · Lezione 30 · Avanzato · Versione: 2
- Java · Lezione 54 · Intermedio · Versione: 2
- Java · Lezione 58 · Intermedio · Versione: 2