Mis vahe on volatile ja atomaarsete muutujate vahel?

volatile tagab muutujate muutuste nähtavuse erinevate voogude vahel ning keelab kompilaatoril ja JVM-il ümber korraldada selle muutujaga seotud juhiseid. See tagab, et volatile-muutujat lugedes näeb voog viimast kirjutatud väärtust. Kuid volatile ei taga koostisosade operatsioonide (näiteks inkrement) atomaarset täitmist.

java.util.concurrent.atomic paketi atomaarklassid (näiteks AtomicInteger, AtomicLong, AtomicReference) kasutavad madala taseme atomaarseid operatsioone, nagu Compare-And-Swap (CAS), mis teostatakse riistvara tasemel. Need tagavad lugemise-muutmise-kirjutamise operatsioonide atomaarse täitmise ilma synchronized-i kasutamata:

Võrdlus:

Omadus	volatile	Atomaarne muutuja (AtomicInteger jms)
Atomaarsus	Ei taga koostisosade operatsioonide atomaarset täitmist.	Tagab operatsioonide atomaarse täitmise (CAS).
Nähtavus	Tagab muudatuste nähtavuse teistele voogudele.	Tagab nähtavuse (CAS-i kõrvalmõju).
Kasutus	Lihtne lugemine/kirjutamine nähtavuse tagamiseks.	Atomaarsete operatsioonide jaoks, nt. inkrement, CAS.
Kulud	Vähem kui synchronized.	Tavaliselt väiksemad kui synchronized, madala konkurentsiga tingimustes.

volatile näide:

class SharedData {
    volatile boolean flag = false; // Muutuse nähtavus

    public void setFlag() {
        flag = true;
    }

    public boolean isFlag() {
        return flag;
    }
}

AtomicInteger näide:

import java.util.concurrent.atomic.AtomicInteger;

class Counter {
    AtomicInteger count = new AtomicInteger(0); // Atomaarne loendur

    public void increment() {
        count.incrementAndGet(); // Atomaarne inkrement
    }

    public int getCount() {
        return count.get();
    }
}