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