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

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

Fuentes