Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

AtomicIntegerFieldUpdater — actualizaciones atómicas de un campo int

AtomicIntegerFieldUpdater ofrece operaciones atómicas sobre el campo volatile int de un objeto existente. Un mismo updater puede servir para varias instancias de una clase, sin necesidad de crear un objeto AtomicInteger independiente para cada campo.

Versión: Java SE 21; repository runtime, production runtime not attested

Sintaxis

AtomicIntegerFieldUpdater<T> updater = AtomicIntegerFieldUpdater.newUpdater(targetClass, "fieldName"); // targetClass is a Class<T>
int current = updater.get(obj);
boolean changed = updater.compareAndSet(obj, expect, update);

AtomicIntegerFieldUpdater<T>, del paquete java.util.concurrent.atomic, opera sobre un campo volatile int seleccionado de objetos de tipo T. El valor permanece en el objeto y el updater se puede compartir entre instancias. Estas utilidades permiten, entre otras cosas, actualizar campos de forma independiente en estructuras de datos concurrentes.

AtomicIntegerFieldUpdater.newUpdater(targetClass, "fieldName") vincula un updater a un campo. El argumento targetClass es un valor de tipo Class<T>. El campo debe ser un volatile int no estático y estar accesible para el código que crea el updater según las reglas de acceso de Java. Una declaración, un nombre o un acceso no válidos provocan una excepción durante la creación.

get y compareAndSet son métodos de instancia que se invocan sobre el updater. updater.get(obj) lee el campo. updater.compareAndSet(obj, expect, update) escribe update solo si el valor actual es == expect; devuelve true si tiene éxito y false si no coincide. Leer y después escribir por separado no sustituye esta operación.

La garantía de atomicidad cubre las llamadas a compareAndSet y set del mismo updater, no cualquier otra modificación del campo. Por tanto, evita mezclar mecanismos de actualización independientes para un estado compartido. El ejemplo de un solo hilo muestra un cambio aceptado y otro rechazado; no es una prueba de corrección en concurrencia.

Ejemplos

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class Main {
    private volatile int state = 0;
    private static final AtomicIntegerFieldUpdater<Main> STATE =
            AtomicIntegerFieldUpdater.newUpdater(Main.class, "state");

    public static void main(String[] args) {
        Main item = new Main();
        System.out.println(STATE.get(item));
        System.out.println(STATE.compareAndSet(item, 0, 1));
        System.out.println(STATE.compareAndSet(item, 0, 2));
        System.out.println(STATE.get(item));
    }
}

Resultado

0
true
false
1

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes