CKTIS / Java
StampedLock: lettura ottimistica, scrittura e ripiego sul lock di lettura
Impara quando usare i dati di una lettura ottimistica e come ripetere la lettura con un lock condiviso da rilasciare usando lo stamp corretto.
Versione: Java SE 21
Sintassi
java.util.concurrent.locks.StampedLock — Java SE 21
public long tryOptimisticRead()
public boolean validate(long stamp)
public long writeLock()
public void unlockWrite(long stamp)
public long readLock()
public void unlockRead(long stamp)In Java SE 21, java.util.concurrent.locks.StampedLock supporta la scrittura esclusiva, la lettura condivisa e la lettura ottimistica. tryOptimisticRead() non attende e non acquisisce un lock: restituisce uno stamp di tipo long, oppure 0L se il lock è già detenuto in scrittura. Uno stamp ottimistico non richiede alcun rilascio.
Se lo stamp è diverso da zero, copia i campi necessari in variabili locali, poi chiama validate(long) sullo stesso lock. Per uno stamp ottimistico recente, true significa che non è stato acquisito alcun lock di scrittura da quando lo stamp è stato emesso. Non protegge da scritture successive. validate(0L) restituisce sempre false. Prima di una convalida riuscita, le copie possono essere incoerenti: non usarle in chiamate o operazioni che presuppongono coerenza. Se la convalida restituisce false, scartale tutte.
writeLock() acquisisce il lock in modo esclusivo e attende se necessario. L’acquisizione stessa invalida gli stamp ottimistici precedenti, anche se i dati non cambiano e anche dopo il rilascio del lock. Modifica i dati protetti sotto il lock di scrittura e passa il relativo stamp a unlockWrite(long) in finally.
Con uno stamp pari a 0L o una convalida fallita, usa readLock() per acquisire un lock condiviso, attendendo se necessario. Rileggi tutti i campi necessari e chiama unlockRead(long) in finally con lo stamp restituito da readLock(), non con quello ottimistico. I metodi di rilascio sollevano IllegalMonitorStateException se lo stamp non corrisponde allo stato del lock. Il lock non è rientrante: non cercare di acquisirlo di nuovo mentre lo detieni. Gli stamp non sono credenziali di sicurezza.
Esempi
import java.util.concurrent.locks.StampedLock;
public class StampedLockDemo {
private final StampedLock lock = new StampedLock();
private int value = 10;
private void write(int newValue) {
long writeStamp = lock.writeLock();
try {
value = newValue;
} finally {
lock.unlockWrite(writeStamp);
}
}
private void demo() {
long firstStamp = lock.tryOptimisticRead();
int firstCopy = value;
boolean firstValid = lock.validate(firstStamp);
System.out.println("first valid: " + firstValid);
if (firstValid) {
System.out.println("first value: " + firstCopy);
}
long secondStamp = lock.tryOptimisticRead();
int secondCopy = value;
write(20);
boolean secondValid = lock.validate(secondStamp);
System.out.println("second valid: " + secondValid);
if (!secondValid) {
long readStamp = lock.readLock();
try {
secondCopy = value;
} finally {
lock.unlockRead(readStamp);
}
}
System.out.println("second value: " + secondCopy);
}
public static void main(String[] args) {
new StampedLockDemo().demo();
}
}Risultato
first valid: true first value: 10 second valid: false second value: 20
L’esempio usa un solo thread. La prima lettura supera la convalida e produce `10`. Nella seconda, la scrittura di `20` avviene apposta tra la copia del campo e la convalida. La copia obsoleta è sostituita da `20`, letto sotto un lock rilasciato con `readStamp`.
Lezioni correlate
- Java · Lezione 29 · Avanzato · Versione: 2