Quelle est la différence entre volatilité et atomicité dans le contexte de la programmation multithread?

volatile garantit la visibilité des modifications d'une variable par tous les threads. Lorsqu'un thread écrit une valeur dans une variable volatile, cette modification devient immédiatement visible pour les autres threads. Il interdit également le réarrangement des opérations de lecture et d'écriture pour les variables volatile.

Les opérations atomiques (classes atomiques dans le paquet java.util.concurrent.atomic) garantissent qu'une opération sur une variable est effectuée comme une unité indivisible et ne peut pas être interrompue par un autre thread. Cela assure la correction des opérations d'incrémentation, de décrémentation et de Compare-And-Swap sans utiliser synchronized.

Différence clé : volatile ne garantit que la visibilité, mais pas l'atomicité des opérations composées (par exemple, i++ — qui est lecture, incrémentation et écriture). Les classes atomiques garantissent à la fois l'atomicité des opérations individuelles et la visibilité.

Exemple :

class VolatileCounter {
    volatile int count = 0;

    public void increment() {
        // Cette opération N'EST PAS atomique
        count++;
    }
}

class AtomicCounter {
    java.util.concurrent.atomic.AtomicInteger count = new java.util.concurrent.atomic.AtomicInteger(0);

    public void increment() {
        // Cette opération EST ATOMIQUE
        count.incrementAndGet();
    }
}