Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

AtomicInteger: leggere, incrementare, azzerare e riprovare con CAS

Inizializza un contatore atomico, leggi o sostituisci il suo valore e incrementalo in una sola operazione. Usa un ciclo CAS per riprovare un aggiornamento condizionale.

Versione: Java SE 21

Sintassi

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, nel package java.util.concurrent.atomic, contiene un valore modificabile di tipo int. Il costruttore AtomicInteger(int) imposta il valore iniziale. get() restituisce l’int corrente senza modificarlo. set(int newValue) sostituisce il valore senza condizioni e non restituisce nulla (void). Le due operazioni hanno rispettivamente la semantica di lettura e scrittura volatile. set(0) azzera lo stesso contatore.

incrementAndGet() aggiunge 1 in modo atomico e restituisce il nuovo int; getAndIncrement() restituisce il valore precedente. Per un semplice incremento, usa incrementAndGet() invece di set(get() + 1): tra lettura e scrittura può avvenire un altro aggiornamento, che verrebbe sovrascritto. Anche la lettura seguita dall’azzeramento non è una singola operazione atomica.

compareAndSet(int expectedValue, int newValue) verifica in modo atomico se il valore corrente è uguale a expectedValue. Se coincide, scrive newValue e restituisce true; altrimenti restituisce false senza scrivere. In un ciclo CAS scritto a mano, leggi con get(), calcola il nuovo valore e chiama compareAndSet. Se ottieni false, rileggi e ricalcola prima di riprovare; se ottieni true, esci dal ciclo. CAS verifica il valore corrente, non la cronologia delle modifiche.

Esempi

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

Risultato

3
0
5
CAS retry
7

Il contatore passa per `0 → 3 → 0 → 5`. Il primo tentativo CAS si aspetta `0` ma trova `5`, quindi il programma stampa `CAS retry`. Dopo una nuova lettura, CAS scrive `7`. Tutto avviene in un solo thread.

Lezioni correlate

  • Java · Lezione 32 · Avanzato · Versione: 2
  • Java · Lezione 55 · Intermedio · Versione: 2

Fonti