Java Academy · leksjon

Atomiske variabler: oppdateringer uten låser

Bruk AtomicInteger, AtomicLong og AtomicReference til trådsikre tellere uten låser.

Leksjon 3 av 413 trinn

Atomiske variabler: oppdateringer uten låser er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

Problemet med ikke-atomiske operasjoner

En enkel økning med count++ er IKKE trådsikker — den består av tre operasjoner: les, legg til, skriv. Samtidige tråder kan flette disse operasjonene inn i hverandre, noe som fører til tapte oppdateringer. Atomiske variabler løser dette uten låser.

// UNSAFE:
int count = 0;
// Thread A reads count=0, Thread B reads count=0
// Both write 1 — second update lost!
count++; // NOT thread-safe

// SAFE:
import java.util.concurrent.atomic.*;
AtomicInteger atomicCount = new AtomicInteger(0);
atomicCount.incrementAndGet(); // atomic, lock-free

Grunnleggende om AtomicInteger

AtomicInteger tilbyr heltallsoperasjoner som garantert er atomiske, ved hjelp av CPU-instruksjoner for compare-and-swap (CAS) — ingen låser er nødvendig.

AtomicInteger counter = new AtomicInteger(0);

counter.set(10);                   // set to 10
System.out.println(counter.get()); // 10

int prev = counter.getAndIncrement(); // returns 10, sets to 11
int curr = counter.incrementAndGet(); // sets to 12, returns 12
counter.addAndGet(5);                 // adds 5, returns 17
counter.decrementAndGet();            // subtracts 1, returns 16

compareAndSet: CAS-operasjonen

compareAndSet(expected, update) oppdaterer verdien atomisk bare hvis den nåværende verdien er lik den forventede verdien. Returnerer true hvis det lykkes. Dette er grunnlaget for alle låsefrie algoritmer.

AtomicInteger ai = new AtomicInteger(5);

boolean updated = ai.compareAndSet(5, 10); // current==5? set to 10
System.out.println(updated); // true
System.out.println(ai.get()); // 10

boolean failed = ai.compareAndSet(5, 20); // current==10, not 5 → fails
System.out.println(failed); // false
System.out.println(ai.get()); // still 10

AtomicLong for tellere

AtomicLong er 64-bitersvarianten. Den brukes ofte til sekvensgeneratorer og treff tellere:

AtomicLong seq = new AtomicLong(0);

// Thread-safe sequence generator:
long nextId() {
    return seq.incrementAndGet();
}

System.out.println(nextId()); // 1
System.out.println(nextId()); // 2
System.out.println(nextId()); // 3

AtomicBoolean

Et trådsikkert boolsk flagg. Brukes ofte til initialisering én gang eller som signal ved avslutning:

AtomicBoolean initialized = new AtomicBoolean(false);

void initOnce() {
    // compareAndSet: only first caller succeeds
    if (initialized.compareAndSet(false, true)) {
        System.out.println("Initializing...");
        // perform expensive init
    } else {
        System.out.println("Already initialized");
    }
}

AtomicReference

AtomicReference<V> tilbyr atomiske oppdateringer av en objektreferanse. Brukes til å implementere låsefrie datastrukturer:

import java.util.concurrent.atomic.*;

record Config(String host, int port) {}

AtomicReference<Config> configRef =
    new AtomicReference<>(new Config("localhost", 8080));

// Hot-swap the configuration atomically:
Config oldConfig = configRef.get();
Config newConfig = new Config("prod.example.com", 443);

boolean swapped = configRef.compareAndSet(oldConfig, newConfig);
System.out.println(swapped); // true
System.out.println(configRef.get()); // Config[host=prod.example.com, port=443]

updateAndGet / getAndUpdate

Bruk en funksjon atomisk ved hjelp av en intern CAS-løkke som prøver på nytt:

AtomicInteger value = new AtomicInteger(10);

// Apply function atomically: square the value
int newVal = value.updateAndGet(x -> x * x);
System.out.println(newVal); // 100

// Get old, then apply:
int old = value.getAndUpdate(x -> x + 1);
System.out.println(old);   // 100
System.out.println(value.get()); // 101

accumulateAndGet

Kombiner den nåværende verdien med en angitt verdi ved hjelp av en funksjon:

AtomicInteger max = new AtomicInteger(0);

// Keep running maximum:
max.accumulateAndGet(42, Math::max); // max(0, 42) = 42
max.accumulateAndGet(15, Math::max); // max(42, 15) = 42
max.accumulateAndGet(99, Math::max); // max(42, 99) = 99

System.out.println(max.get()); // 99

LongAdder for tellere med høy konkurranse

Ved høy konkurranse mellom tråder kan CAS-forsøkene på nytt i AtomicLong redusere ytelsen. LongAdder bruker flere celler for å redusere konkurransen:

import java.util.concurrent.atomic.*;

LongAdder adder = new LongAdder();

// Multiple threads can call add() with minimal contention:
adder.increment();
adder.add(5);
adder.increment();

System.out.println(adder.sum()); // 7
// Note: sum() is NOT atomic with add() — use only when no concurrent adds

Atomiske tabeller

AtomicIntegerArray / AtomicLongArray tilbyr atomiske operasjoner på enkeltelementer i tabeller:

AtomicIntegerArray arr = new AtomicIntegerArray(5);

arr.set(0, 10);
arr.incrementAndGet(0);
arr.compareAndSet(2, 0, 42); // index 2: if 0, set 42

System.out.println(arr.get(0)); // 11
System.out.println(arr.get(2)); // 42

Når bør atomiske variabler brukes i stedet for låser

Bruk atomiske variabler når:

Oppdateringer gjelder én variabel (tellere, flagg, referanser)
Det er lite konkurranse mellom tråder
Låsefri ytelse er viktig

Bruk låser når:

Flere variabler må oppdateres atomisk
Det trengs kompleks betingelseslogikk
Det er svært høy konkurranse mellom tråder (CAS-forsøk på nytt reduserer ytelsen)

Hurtigsjekk

Hva garanterer compareAndSet(expected, update)?

Besvar den i den interaktive leksjonen

Oppsummering: Atomiske variabler

Viktigste punkter:

Atomiske typer bruker CPU-instruksjoner for CAS — låsefrie og trådsikre
AtomicInteger/Long/Boolean/Reference for atomiske operasjoner på én variabel
compareAndSet er grunnlaget for låsefrie algoritmer
updateAndGet/accumulateAndGet for funksjonelle oppdateringer
LongAdder for tellere i scenarier med høy konkurranse

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 104
Leksjoner: 374

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Atomiske variabler: oppdateringer uten låser» gratis?

Ja – hele teksten i «Atomiske variabler: oppdateringer uten låser» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Atomiske variabler: oppdateringer uten låser»?

Bruk AtomicInteger, AtomicLong og AtomicReference til trådsikre tellere uten låser. Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Atomiske variabler: oppdateringer uten låser»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

ReentrantLock kontra synchronized
ReadWriteLock for leser-skriver-scenarioer
Atomiske variabler: oppdateringer uten låser
StampedLock og optimistiske lesinger

← Tilbake til Java Academy