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

CKTIS / Java

AtomicLong: valor inicial e incremento atómico

Defina o valor inicial de um contador partilhado, obtenha cada número após o incremento e veja por que razão o objeto sentinela `POISON` recebe o menor número.

Versão: Java SE 21

Sintaxe

import java.util.concurrent.atomic.AtomicLong;

// Constructor: public AtomicLong(long initialValue)
// Instance method: public final long incrementAndGet()
AtomicLong seq = new AtomicLong(40L);
long next = seq.incrementAndGet();

Em Java SE 21, AtomicLong, do pacote java.util.concurrent.atomic, guarda um valor long mutável. O construtor AtomicLong(long) cria um contador com o valor inicial indicado; a variante sobrecarregada AtomicLong() começa em 0. O valor inicial ainda não é o primeiro número atribuído.

AtomicLong.incrementAndGet é um método de instância sem argumentos. Numa única operação atómica, soma 1 e devolve o novo valor do tipo long. getAndIncrement() também incrementa o contador, mas devolve o valor anterior. A leitura e a escrita seguem a semântica de memória de volatile, conforme especificado por VarHandle.getAndAdd.

Se as threads se limitarem a incrementar a mesma instância, os números atribuídos são distintos e estritamente crescentes pela ordem das atualizações até ocorrer um transbordo. A seguir a Long.MAX_VALUE vem Long.MIN_VALUE, sem lançar uma exceção. O contador não torna atómicas a construção de um objeto nem a sua inserção numa fila, nem determina a ordem pela qual as threads acabam o seu trabalho.

Os inicializadores dos campos static do exemplo são executados pela ordem em que aparecem no código-fonte. Primeiro é criado o contador partilhado SEQ e depois o objeto sentinela POISON. O construtor deste faz o primeiro incremento e guarda 41, o menor número do exemplo. As entradas normais são criadas mais tarde em main.

Exemplos

import java.util.concurrent.atomic.AtomicLong;

public class SequenceDemo {
    private static final AtomicLong SEQ = new AtomicLong(40L);
    private static final Entry POISON = new Entry();

    private static final class Entry {
        private final long seq;

        private Entry() {
            seq = SEQ.incrementAndGet();
        }
    }

    public static void main(String[] args) {
        Entry first = new Entry();
        Entry second = new Entry();
        System.out.println("POISON: " + POISON.seq);
        System.out.println("first: " + first.seq);
        System.out.println("second: " + second.seq);
    }
}

Resultado

POISON: 41
first: 42
second: 43

O exemplo usa uma única thread: `40` é o valor inicial, e `41`, `42` e `43` são os números devolvidos pelos incrementos sucessivos.

Lições relacionadas

  • Java · Lição 38 · Avançado · Versão: 2

Fontes