CKTIS / Java
ReadWriteLock — lock separati per lettura e scrittura
ReadWriteLock espone lock associati per la lettura e la scrittura: più lettori possono condividere l’accesso, mentre la scrittura richiede accesso esclusivo. Scopri readLock() e writeLock(), la visibilità delle modifiche e il rilascio sicuro dei lock.
Versione: Java SE 21; repository runtime, production runtime not attested
Sintassi
ReadWriteLock rw = new ReentrantReadWriteLock();
Lock read = rw.readLock();
Lock write = rw.writeLock();
read.lock();
try {
// Read protected state.
} finally {
read.unlock();
}
write.lock();
try {
// Modify protected state.
} finally {
write.unlock();
}java.util.concurrent.locks.ReadWriteLock è un’interfaccia che rappresenta una coppia di lock associati. ReadWriteLock.readLock() restituisce un Lock per la lettura e ReadWriteLock.writeLock() uno per la scrittura; chiamare questi metodi non acquisisce un lock. Più lettori possono operare contemporaneamente se non ci sono scrittori; la scrittura è esclusiva.
Chiama lock() sull’oggetto restituito prima della sezione protetta e unlock() in finally, collocando lock() prima di try. Tutti gli accessi allo stato protetto devono seguire lo stesso protocollo. Non modificare lo stato sotto il lock di lettura. L’acquisizione riuscita del lock di lettura rende visibili le modifiche pubblicate da un precedente rilascio del lock di scrittura associato.
Un’implementazione tipica è ReentrantReadWriteLock. La modalità predefinita non garantisce un ordine equo. Non tentare di acquisire il lock di scrittura mentre mantieni ancora quello di lettura: questa implementazione non supporta tale conversione. Dopo aver rilasciato il lock di lettura e acquisito quello di scrittura, verifica di nuovo la condizione, perché lo stato potrebbe essere cambiato. Queste regole dell’implementazione non sono garanzie aggiuntive dell’interfaccia.
Questo approccio può essere utile quando le letture sono frequenti e le scritture meno frequenti, ma il costo aggiuntivo può annullarne i vantaggi; misura le prestazioni. L’esempio protegge value e stampa 42 in modo deterministico. Le chiamate sequenziali in main mostrano l’uso dell’API, non l’esecuzione parallela né la correttezza con ogni possibile interleaving dei thread.
Esempi
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Main {
private final ReadWriteLock rw = new ReentrantReadWriteLock();
private int value;
public int get() {
Lock read = rw.readLock();
read.lock();
try {
return value;
} finally {
read.unlock();
}
}
public void set(int next) {
Lock write = rw.writeLock();
write.lock();
try {
value = next;
} finally {
write.unlock();
}
}
public static void main(String[] args) {
Main cell = new Main();
cell.set(42);
System.out.println(cell.get());
}
}Risultato
42
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.