Forklar atomiske operasjoner, memory visibility og memory barriers.

Question

IT Interview Practice · Accepted Answer

**En atomisk operasjon fullføres udelelig — ingen annen tråd ser en halvferdig tilstand; memory visibility handler om hvorvidt én tråds skriving blir sett av en annen; memory barriers håndhever rekkefølge slik at de skrivingene blir synlige.** Låser er ikke den eneste bekymringen — det er minnemodellen også.

## Atomisitet

En atomisk operasjon (f.eks. `fetch_add`, compare-and-swap) utføres som ett udelelig steg, så ingen race splitter den. Maskinvare og språk tilbyr atomics for tellere og flagg uten en full lås.

```java
AtomicInteger counter = new AtomicInteger();
counter.incrementAndGet();  // atomic read-modify-write, no lock
```

## Synlighet og omrokkering

Moderne CPU-er og kompilatorer cacher verdier i registre og omorganiserer instruksjoner for fart. Så en skriving i én tråd kan ligge i en store buffer, usynlig for andre, og operasjoner kan fremstå i feil rekkefølge.

```java
// Without 'volatile', thread B may loop forever:
volatile boolean ready = false;  // volatile → writes are visible + ordered
// Thread A: data = 42; ready = true;
// Thread B: while (!ready) {}  then read data
```

## Memory barriers

En **barrier** (fence) er en instruksjon som hindrer omrokkering på tvers av den og flusher/laster minne, og garanterer rekkefølge. `volatile`, `synchronized` og atomics setter inn de riktige barrierene slik at et happens-before-forhold holder: det A skrev før den frigjorde, ser B etter at den tar låsen.

## Hvorfor det er viktig

Atomisitet alene er ikke nok — uten synlighetsgarantier kan en korrekt låst verdi likevel leses utdatert. Dette forklarer hvorfor `volatile` finnes, hvorfor double-checked locking er subtilt, og hvorfor lock-free-kode trenger nøye valg av memory ordering. Det er forskjellen mellom "funker på min maskin" og korrekt på ekte flerkjernemaskinvare.

Atomisitet

Synlighet og omrokkering

Memory barriers

Hvorfor det er viktig

Relaterte spørsmål