CKTIS / Java
Lock — acquisizione e rilascio espliciti del lock
L’interfaccia java.util.concurrent.locks.Lock consente di controllare esplicitamente i lock. Scopri la coppia lock()/unlock(), il modello sicuro try/finally e un esempio in cui ReentrantLock protegge un contatore condiviso.
Versione: Java SE 21; repository runtime, production runtime not attested
Sintassi
Lock lock = new ReentrantLock();
lock.lock();
try {
// protected operations
} finally {
lock.unlock();
}java.util.concurrent.locks.Lock è un’interfaccia per il locking esplicito; ReentrantLock è un’implementazione che offre mutua esclusione e rientro da parte dello stesso thread. Non tutte le implementazioni di Lock devono avere queste proprietà.
Lock.lock() acquisisce il lock, attendendo se necessario; Lock.unlock() lo rilascia. Chiama lock.lock() prima di try e lock.unlock() in finally. A differenza di synchronized, il rilascio non è automatico. finally garantisce il rilascio anche se si verifica un’eccezione nel codice protetto.
Tutti gli accessi concorrenti allo stato protetto devono seguire lo stesso protocollo di locking. L’acquisizione del lock da parte di un thread che non lo detiene già e il rilascio completo del lock, se vanno a buon fine, hanno gli stessi effetti di sincronizzazione della memoria rispettivamente dell’acquisizione e del rilascio di un monitor. Lock non richiede tali effetti per le operazioni non riuscite né per le acquisizioni rientranti e i relativi rilasci. synchronized (lock) non sostituisce lock.lock().
Con ReentrantLock, ogni acquisizione richiede un rilascio corrispondente; se un thread che non detiene il lock chiama unlock(), viene generata IllegalMonitorStateException. L’interfaccia offre anche tryLock() e lockInterruptibly() per altre strategie di attesa.
L’esempio usa un unico lock condiviso per entrambe le operazioni count++. Dopo entrambe le chiamate a join(), il programma stampa 2, indipendentemente dall’ordine di esecuzione dei thread. Ambito della documentazione: Java SE 21; l’ambiente di esecuzione del repository e quello di produzione non sono attestati.
Esempi
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Main {
private static final Lock lock = new ReentrantLock();
private static int count = 0;
private static void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
Thread first = new Thread(Main::increment);
Thread second = new Thread(Main::increment);
first.start();
second.start();
first.join();
second.join();
System.out.println(count);
}
}Risultato
2
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.