Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

VarHandle : lecture acquire, écriture release et CAS atomique

Avec Java SE 21, obtenez un accès à un champ `int` ordinaire, choisissez l’ordre mémoire des lectures et des écritures et effectuez une mise à jour conditionnelle atomique.

Version : Java SE 21

Syntaxe

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);

Dans java.lang.invoke, MethodHandles.lookup() renvoie un objet de recherche doté des droits d’accès de la classe appelante. MethodHandles.Lookup.findVarHandle prend la classe du récepteur à partir de laquelle la recherche commence, ainsi que le nom et le type exact du champ d’instance (int.class, pas Integer.class). Cette classe peut être une sous-classe qui hérite du champ, à condition que l’objet de recherche y ait accès. Le handle n’est pas lié à un objet : passez l’instance en premier argument de chaque opération. Pour un champ statique, utilisez findStaticVarHandle ; ses opérations ne prennent pas d’instance.

L’accès est contrôlé à la création du handle. Un champ introuvable avec le nom et le type indiqués entraîne NoSuchFieldException. Un accès refusé ou un champ statique trouvé par findVarHandle entraîne IllegalAccessException. Ne transmettez pas un handle de champ privé à du code non fiable : il pourrait l’utiliser sans nouveau contrôle d’accès au champ.

setRelease(obj, value) écrit avec l’ordre release et (int) handle.getAcquire(obj) lit avec l’ordre acquire. Si la lecture acquire observe l’écriture release sur le même champ, les accès mémoire qui précèdent l’écriture sont ordonnés avant ceux qui suivent la lecture. La lecture n’attend pas une valeur plus récente. C’est le mode du handle qui impose l’ordre : le champ int ordinaire n’a pas besoin d’être volatile, et sa lecture directe n’a pas la sémantique acquire.

compareAndSet(obj, expected, update) compare la valeur int courante avec == et, si elle correspond, écrit la nouvelle valeur et renvoie true, le tout atomiquement. Sinon, il renvoie false sans écrire. La lecture et, en cas de succès, l’écriture ont la sémantique volatile. Les méthodes d’accès ont une signature polymorphe : malgré Object... dans les déclarations, les types au site d’appel, dont le cast (int) du résultat, déterminent le descripteur de l’appel. Un type incompatible peut entraîner WrongMethodTypeException, un cast de référence qui échoue, ClassCastException, et un mode non pris en charge (comme l’écriture dans un champ final), UnsupportedOperationException.

Exemples

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);
    }
}

Résultat

observed=1
updated=true
staleUpdate=false
finalState=2

Dans un seul thread, le programme écrit `1`, lit `1`, remplace cette valeur par `2` avec CAS, puis rejette la seconde tentative qui attend encore `1`. La sortie montre les appels, pas la visibilité entre threads.

Leçons associées

  • Java · Leçon 57 · Avancé · Version : 2

Sources