CKTIS / Java
VarHandle: lettura acquire, scrittura release e CAS atomico
In Java SE 21 puoi ottenere un handle per un normale campo `int`, scegliere l’ordinamento della memoria in lettura e scrittura e aggiornare il valore in modo condizionale e atomico.
Versione: Java SE 21
Sintassi
VarHandle handle = MethodHandles.lookup().findVarHandle(VarHandleDemo.class, "state", int.class);
int observed = (int) handle.getAcquire(demo);
handle.setRelease(demo, newValue);
boolean updated = handle.compareAndSet(demo, expectedValue, newValue);In java.lang.invoke, MethodHandles.lookup() restituisce un oggetto di ricerca con i permessi di accesso della classe chiamante. MethodHandles.Lookup.findVarHandle accetta la classe del ricevitore da cui parte la ricerca, il nome e il tipo esatto del campo di istanza (int.class, non Integer.class). La classe del ricevitore può essere una sottoclasse che eredita il campo, purché l’oggetto di ricerca abbia accesso al campo. L’handle non è legato a un oggetto: passa l’istanza come primo argomento di ogni operazione. Per un campo statico usa findStaticVarHandle; le sue operazioni non richiedono un’istanza.
L’accesso viene verificato alla creazione dell’handle. Se non esiste un campo con il nome e il tipo indicati, viene lanciata NoSuchFieldException. Se l’accesso è negato o findVarHandle trova un campo statico, viene lanciata IllegalAccessException. Non passare a codice non fidato un handle per un campo privato: potrebbe usarlo senza un altro controllo di accesso al campo.
setRelease(obj, value) scrive con ordinamento release e (int) handle.getAcquire(obj) legge con ordinamento acquire. Se la lettura acquire osserva la scrittura release sullo stesso campo, gli accessi alla memoria precedenti alla scrittura sono ordinati prima di quelli successivi alla lettura. La lettura non attende un valore più recente. L’ordinamento dipende dalla modalità dell’handle: il normale campo int non deve essere dichiarato volatile e una lettura diretta non ha semantica acquire.
compareAndSet(obj, expected, update) confronta l’int corrente con == e, se coincide, scrive il nuovo valore e restituisce true, in un’unica operazione atomica. Altrimenti restituisce false senza scrivere. La lettura e, in caso di successo, la scrittura hanno semantica volatile. I metodi di accesso hanno firma polimorfica: nonostante Object... nelle dichiarazioni, i tipi nel punto della chiamata, incluso il cast (int) del risultato, determinano il descrittore di chiamata. Un tipo incompatibile può causare WrongMethodTypeException, un cast di riferimento non riuscito ClassCastException e una modalità non supportata (come scrivere in un campo final) UnsupportedOperationException.
Esempi
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
public class VarHandleDemo {
private int state;
public static void main(String[] args) throws ReflectiveOperationException {
VarHandle stateHandle = MethodHandles.lookup()
.findVarHandle(VarHandleDemo.class, "state", int.class);
VarHandleDemo demo = new VarHandleDemo();
stateHandle.setRelease(demo, 1);
int observed = (int) stateHandle.getAcquire(demo);
boolean updated = stateHandle.compareAndSet(demo, observed, 2);
boolean staleUpdate = stateHandle.compareAndSet(demo, 1, 3);
int finalState = (int) stateHandle.getAcquire(demo);
System.out.println("observed=" + observed);
System.out.println("updated=" + updated);
System.out.println("staleUpdate=" + staleUpdate);
System.out.println("finalState=" + finalState);
}
}Risultato
observed=1 updated=true staleUpdate=false finalState=2
In un solo thread, il programma scrive `1`, legge `1`, lo cambia in `2` tramite CAS e respinge il secondo tentativo, che si aspetta ancora `1`. L’output mostra le chiamate, non la visibilità tra thread.
Lezioni correlate
- Java · Lezione 57 · Avanzato · Versione: 2