Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

AtomicInteger: ler, incrementar, repor a zero e voltar a tentar com CAS

Inicializa um contador atómico, lê ou substitui o seu valor e incrementa-o numa só operação. Usa um ciclo CAS para voltar a tentar uma atualização condicional.

Versão: Java SE 21

Sintaxe

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, do pacote java.util.concurrent.atomic, contém um valor mutável do tipo int. O construtor AtomicInteger(int) define o valor inicial. get() devolve o int atual sem o alterar. set(int newValue) substitui o valor sem condições e não devolve nada (void). Os métodos têm, respetivamente, semântica de leitura e de escrita volatile. set(0) repõe o mesmo contador a zero.

incrementAndGet() soma 1 de forma atómica e devolve o novo int; getAndIncrement() devolve o valor anterior. Para um incremento simples, usa incrementAndGet() em vez de set(get() + 1): entre a leitura e a escrita pode ocorrer outra atualização, que acaba por ser sobrescrita. Ler e depois repor a zero também não é uma única operação atómica.

compareAndSet(int expectedValue, int newValue) verifica de forma atómica se o valor atual é igual a expectedValue. Se for igual, escreve newValue e devolve true; caso contrário, devolve false sem escrever. Num ciclo CAS escrito à mão, lê com get(), calcula o novo valor e chama compareAndSet. Se obtiveres false, volta a ler e a calcular antes de tentares novamente; se obtiveres true, sai do ciclo. CAS verifica o valor atual, não o histórico de alterações.

Exemplos

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

O contador passa por `0 → 3 → 0 → 5`. A primeira tentativa de CAS espera `0`, mas encontra `5`, pelo que o programa apresenta `CAS retry`. Após nova leitura, CAS escreve `7`. Tudo decorre numa única thread.

Lições relacionadas

  • Java · Lição 32 · Avançado · Versão: 2
  • Java · Lição 55 · Intermédio · Versão: 2

Fontes