KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

AtomicInteger: lezen, verhogen, resetten en opnieuw proberen met CAS

Initialiseer een atomaire teller, lees of vervang de waarde en verhoog die in één bewerking. Gebruik een CAS-lus om een voorwaardelijke update opnieuw te proberen.

Versie: Java SE 21

Syntax

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 uit java.util.concurrent.atomic bevat één veranderlijke int-waarde. De constructor AtomicInteger(int) stelt de beginwaarde in. get() geeft de huidige int terug zonder die te wijzigen. set(int newValue) vervangt de waarde onvoorwaardelijk en geeft niets terug (void). De methoden hebben respectievelijk de semantiek van een volatile-lees- en schrijfbewerking. set(0) zet dezelfde teller terug op nul.

incrementAndGet() telt atomair 1 op en geeft de nieuwe int terug; getAndIncrement() geeft de vorige waarde terug. Gebruik voor een eenvoudige verhoging incrementAndGet() in plaats van set(get() + 1): tussen het lezen en schrijven kan een andere update plaatsvinden, die vervolgens wordt overschreven. Lezen en daarna resetten is evenmin één atomaire bewerking.

compareAndSet(int expectedValue, int newValue) controleert atomair of de huidige waarde gelijk is aan expectedValue. Zo ja, dan schrijft de methode newValue en geeft ze true terug; zo niet, dan geeft ze false terug zonder te schrijven. Lees in een zelfgeschreven CAS-lus met get(), bereken de nieuwe waarde en roep compareAndSet aan. Bij false lees en bereken je opnieuw voordat je het nog eens probeert; bij true verlaat je de lus. CAS controleert de huidige waarde, niet de wijzigingsgeschiedenis.

Voorbeelden

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

Resultaat

3
0
5
CAS retry
7

De teller doorloopt `0 → 3 → 0 → 5`. De eerste CAS-poging verwacht `0`, maar vindt `5`, dus het programma toont `CAS retry`. Na opnieuw lezen schrijft CAS `7`. Alles draait in één thread.

Gerelateerde lessen

  • Java · Les 32 · Gevorderd · Versie: 2
  • Java · Les 55 · Gemiddeld · Versie: 2

Bronnen