WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

AtomicLong: Anfangswert und atomares Inkrement

Lege den Startwert eines gemeinsamen Zählers fest, lies den Wert nach dem Erhöhen ab und sieh, warum das Markierungsobjekt `POISON` die kleinste Nummer erhält.

Version: Java SE 21

Syntax

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

In Java SE 21 speichert AtomicLong aus java.util.concurrent.atomic einen veränderlichen long-Wert. Der Konstruktor AtomicLong(long) erzeugt einen neuen Zähler mit dem angegebenen Anfangswert; die Überladung AtomicLong() beginnt bei 0. Der Anfangswert ist noch nicht die erste vergebene Nummer.

AtomicLong.incrementAndGet ist eine Instanzmethode ohne Argumente. Sie erhöht den Wert in einer atomaren Operation um 1 und gibt den neuen long-Wert zurück. getAndIncrement() erhöht den Zähler ebenfalls, gibt aber den vorherigen Wert zurück. Für Lesen und Schreiben gilt gemäß VarHandle.getAndAdd die Speichersemantik von volatile.

Wenn Threads dieselbe Instanz ausschließlich inkrementieren, sind die vergebenen Nummern verschieden und steigen in der Reihenfolge der Aktualisierungen bis zum Überlauf streng an. Auf Long.MAX_VALUE folgt Long.MIN_VALUE, ohne Ausnahme. Der Zähler macht weder die Objekterzeugung noch das Einfügen in eine Warteschlange atomar und legt nicht fest, in welcher Reihenfolge die Threads ihre Arbeit beenden.

Die Initialisierer der static-Felder im Beispiel werden in der Reihenfolge des Quelltexts ausgeführt. Zuerst entsteht der gemeinsame Zähler SEQ, dann das Markierungsobjekt POISON. Dessen Konstruktor erhöht den Zähler als Erster und speichert 41, die kleinste Nummer im Beispiel. Die regulären Einträge entstehen später in main.

Beispiele

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

Ergebnis

POISON: 41
first: 42
second: 43

Das Beispiel läuft in einem Thread: `40` ist der Startwert, und `41`, `42` und `43` sind die Rückgabewerte der aufeinanderfolgenden Inkremente.

Zugehörige Lektionen

  • Java · Lektion 38 · Fortgeschritten · Version: 2

Quellen