CKTIS / Java
Lock di lettura e scrittura: readLock(), writeLock(), lock() e unlock()
Più thread possono leggere contemporaneamente gli stessi dati, ma per scrivere serve l’accesso esclusivo. Selezionare un lock non significa acquisirlo.
Versione: Java SE 21
Sintassi
// java.util.concurrent.locks.ReadWriteLock
Lock readLock();
Lock writeLock();
// java.util.concurrent.locks.Lock
void lock();
void unlock();In Java SE 21, ReadWriteLock e Lock sono interfacce del package java.util.concurrent.locks. readLock() e writeLock() restituiscono gli oggetti Lock associati senza acquisirli. Usa un’unica istanza condivisa di ReadWriteLock per proteggere lo stato: il lock di lettura per le operazioni che non modificano nulla, quello di scrittura per le modifiche. Più thread possono detenere contemporaneamente il lock di lettura. Finché un thread detiene il lock di scrittura, nessun altro thread può acquisire uno dei due lock.
lock() e unlock() non ricevono argomenti e hanno tipo di ritorno void. Chiama lock() prima del blocco try: se il lock non è disponibile, il thread attende di acquisirlo. Chiama unlock() sullo stesso Lock in finally per rilasciarlo anche se il codice protetto lancia un’eccezione. L’esempio usa tryLock() senza argomenti, che non attende: restituisce true se acquisisce il lock, false altrimenti. Rilascia il lock solo dopo averlo acquisito.
Dopo il rilascio del lock di scrittura, un thread che acquisisce il lock di lettura associato vede le modifiche effettuate sotto il lock di scrittura. I lock non proteggono il codice che accede allo stato senza usarli.
Con ReentrantReadWriteLock, il thread deve far corrispondere un unlock() a ogni acquisizione. Rilasciare un lock che non detiene provoca IllegalMonitorStateException. Non tentare di acquisire il lock di scrittura mentre detieni solo quello di lettura: lock() non ritorna. Rilascia quello di lettura, acquisisci quello di scrittura e ricontrolla lo stato, perché nel frattempo potrebbe essere cambiato. Nel senso opposto puoi acquisire il lock di lettura mentre detieni ancora quello di scrittura e poi rilasciare quest’ultimo.
Esempi
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockDemo {
private final ReadWriteLock rw = new ReentrantReadWriteLock();
private final Lock read = rw.readLock();
private final Lock write = rw.writeLock();
private int value = 0;
public static void main(String[] args) throws InterruptedException, ExecutionException {
new ReadWriteLockDemo().run();
}
private void run() throws InterruptedException, ExecutionException {
read.lock();
try {
System.out.println("read lock held: " + probeFromAnotherThread());
} finally {
read.unlock();
}
write.lock();
try {
value = 10;
System.out.println("write lock held: " + probeFromAnotherThread());
} finally {
write.unlock();
}
int snapshot;
read.lock();
try {
snapshot = value;
} finally {
read.unlock();
}
System.out.println("read after write: " + snapshot);
}
private String probeFromAnotherThread() throws InterruptedException, ExecutionException {
FutureTask<String> probe = new FutureTask<>(() -> {
String snapshot = "blocked";
if (read.tryLock()) {
try {
snapshot = Integer.toString(value);
} finally {
read.unlock();
}
}
return "reader=" + snapshot + ", writer=" + canAcquireNow(write);
});
new Thread(probe).start();
return probe.get();
}
private static boolean canAcquireNow(Lock lock) {
if (!lock.tryLock()) {
return false;
}
try {
return true;
} finally {
lock.unlock();
}
}
}Risultato
read lock held: reader=0, writer=false write lock held: reader=blocked, writer=false read after write: 10
Mentre il thread principale detiene il lock di lettura, un secondo thread legge `0` ma non può acquisire il lock di scrittura. Dopo l’assegnazione di `10`, mentre il thread principale detiene ancora il lock di scrittura, entrambi i tentativi del secondo thread falliscono. Rilasciato il lock di scrittura, una lettura protetta restituisce `10`. `FutureTask.get()` mantiene quest’ordine senza introdurre pause.
Lezioni correlate
- Java · Lezione 29 · Avanzato · Versione: 2