Mi a különbség a volatile és az atomáris változók között?

A volatile biztosítja a változó változásainak láthatóságát különböző szálak között, és megtiltja a fordítónak és a JVM-nek, hogy újra sorrendbe állítsák a vele kapcsolatos utasításokat. Ez garantálja, hogy volatile változó olvasásakor a szál a legutóbb írt értéket látja. Azonban a volatile nem garantálja az összetett műveletek (pl. növelés) atomitását.

Az java.util.concurrent.atomic csomag atomikus osztályai (pl. AtomicInteger, AtomicLong, AtomicReference) alacsony szintű atomikus műveleteket használnak, mint például a Compare-And-Swap (CAS), amelyek hardver szinten történnek. Garantálják, hogy az olvasás-módosítás-írás műveletek atomikusan végrehajtódnak, anélkül, hogy explicit szinkronizációra lenne szükség synchronized-del.

Összehasonlítás:

Jellemző	volatile	Atomikus változók (AtomicInteger, stb.)
Atomitás	Nem garantálja az összetett műveletek atomitását.	Garantálják az atomitást (CAS).
Láthatóság	Garantálja a változások láthatóságát más szálak számára.	Garantálják a láthatóságot (CAS mellékhatás).
Használat	Egyszerű olvasás/írás láthatóságának biztosítására.	Atomikus műveletekhez, mint növelés, CAS.
Költség	Kevesebb, mint a synchronized.	Általában kevesebb, mint a synchronized, alacsony verseny esetén.

volatile használatának példája:

class SharedData {
    volatile boolean flag = false; // Biztosítja a flag változásának láthatóságát

    public void setFlag() {
        flag = true;
    }

    public boolean isFlag() {
        return flag;
    }
}

AtomicInteger példája:

import java.util.concurrent.atomic.AtomicInteger;

class Counter {
    AtomicInteger count = new AtomicInteger(0); // Atomikus számláló

    public void increment() {
        count.incrementAndGet(); // Atomikus növelés
    }

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