CKTIS / Java
AtomicInteger: leer, incrementar, restablecer y reintentar con CAS
Inicializa un contador atómico, lee o sustituye su valor e increméntalo en una sola operación. Usa un bucle CAS para reintentar una actualización condicional.
Versión: Java SE 21
Sintaxis
import java.util.concurrent.atomic.AtomicInteger;
AtomicInteger counter = new AtomicInteger(initialValue);
int current = counter.get();
boolean changed = counter.compareAndSet(expectedValue, newValue);
int updated = counter.incrementAndGet();
counter.set(newValue);
// initialValue, expectedValue, and newValue are int values.AtomicInteger, del paquete java.util.concurrent.atomic, contiene un valor modificable de tipo int. El constructor AtomicInteger(int) fija el valor inicial. get() devuelve el int actual sin modificarlo. set(int newValue) sustituye el valor de forma incondicional y no devuelve nada (void). Estas operaciones tienen semántica de lectura y escritura volatile, respectivamente. set(0) pone a cero el mismo contador.
incrementAndGet() suma 1 de forma atómica y devuelve el nuevo int; getAndIncrement() devuelve el valor anterior. Para un incremento sencillo, usa incrementAndGet() en lugar de set(get() + 1): otra actualización puede producirse entre la lectura y la escritura y quedar sobrescrita. Leer y después poner a cero tampoco constituye una sola operación atómica.
compareAndSet(int expectedValue, int newValue) comprueba de forma atómica si el valor actual es igual a expectedValue. Si coincide, escribe newValue y devuelve true; si no, devuelve false sin escribir. En un bucle CAS manual, lee con get(), calcula el valor nuevo y llama a compareAndSet. Si devuelve false, vuelve a leer y a calcular antes de reintentar; si devuelve true, sal del bucle. CAS comprueba el valor actual, no el historial de cambios.
Ejemplos
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicCounterDemo {
public static void main(String[] args) {
AtomicInteger counter = new AtomicInteger(0);
for (int i = 0; i < 3; i++) {
counter.incrementAndGet();
}
System.out.println(counter.get());
counter.set(0);
int expected = counter.get();
System.out.println(expected);
for (int i = 0; i < 5; i++) {
counter.incrementAndGet();
}
System.out.println(counter.get());
// The first CAS still expects the value read just after the reset.
while (!counter.compareAndSet(expected, expected + 2)) {
System.out.println("CAS retry");
expected = counter.get();
}
System.out.println(counter.get());
}
}Resultado
3 0 5 CAS retry 7
El contador pasa por `0 → 3 → 0 → 5`. El primer intento CAS espera `0`, pero encuentra `5`, así que el programa imprime `CAS retry`. Tras volver a leer, CAS escribe `7`. Todo ocurre en un solo hilo.
Lecciones relacionadas
- Java · Lección 32 · Avanzado · Versión: 2
- Java · Lección 55 · Intermedio · Versión: 2