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

CKTIS / Java

AtomicLong: valor inicial e incremento atómico

Define el valor inicial de un contador compartido, obtén cada número tras el incremento y descubre por qué el centinela `POISON` recibe el número más bajo.

Versión: Java SE 21

Sintaxis

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

En Java SE 21, AtomicLong, del paquete java.util.concurrent.atomic, contiene un valor long mutable. El constructor AtomicLong(long) crea un contador con el valor inicial indicado; la sobrecarga AtomicLong() empieza en 0. El valor inicial aún no es el primer número asignado.

AtomicLong.incrementAndGet es un método de instancia sin argumentos. En una sola operación atómica, suma 1 y devuelve el nuevo valor de tipo long. getAndIncrement() también incrementa el contador, pero devuelve el valor anterior. La lectura y la escritura tienen la semántica de memoria de volatile, según VarHandle.getAndAdd.

Si los hilos solo incrementan la misma instancia, los números asignados son distintos y crecen estrictamente en el orden de las actualizaciones hasta que se produce un desbordamiento. Después de Long.MAX_VALUE viene Long.MIN_VALUE, sin que se lance una excepción. El contador no hace atómica la construcción de un objeto ni su inserción en una cola, ni determina el orden en que los hilos terminan su trabajo.

Los inicializadores de los campos static del ejemplo se ejecutan en el orden en que aparecen en el código. Primero se crea el contador compartido SEQ y después el centinela POISON. Su constructor realiza el primer incremento y guarda 41, el número más bajo del ejemplo. Las entradas normales se crean más tarde en main.

Ejemplos

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

El ejemplo usa un solo hilo: `40` es el valor inicial y `41`, `42` y `43` son los números que devuelven los incrementos sucesivos.

Lecciones relacionadas

  • Java · Lección 38 · Avanzado · Versión: 2

Fuentes