Qu'est-ce que le mécanisme CAS (Compare-And-Swap) ?

Le mécanisme Compare-And-Swap (CAS) est une opération machine atomique utilisée pour implémenter la synchronisation sans blocage.

Principe de fonctionnement :

1. Lit la valeur actuelle de la cellule mémoire (expectedValue).
2. Tentera d’écrire une nouvelle valeur (newValue) dans cette cellule seulement si la valeur actuelle correspond à expectedValue.
3. Retourne une valeur booléenne : true si l’écriture a réussi (c’est-à-dire qu’il y a eu correspondance), false sinon.

En Java, CAS est implémenté dans les classes du paquet java.util.concurrent.atomic, par exemple, AtomicInteger, AtomicLong, AtomicReference.

Exemple d’utilisation de AtomicInteger :

// java
import java.util.concurrent.atomic.AtomicInteger;

public class CasExample {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        while (true) {
            int expectedValue = count.get(); // Lit la valeur actuelle
            int newValue = expectedValue + 1;
            if (count.compareAndSet(expectedValue, newValue)) {
                // Si la valeur actuelle n’a pas changé depuis la lecture,
                // effectue l’écriture et sort de la boucle
                break;
            }
            // Si la valeur a changé, réessaie
        }
    }
}

Avantages :

• Non bloquant : les threads ne se bloquent pas mutuellement, réduisant les coûts de changement de contexte, surtout en cas de faible concurrence.
• Évite les problèmes de blocages mutuels (deadlock).

Inconvénients :

• Problème ABA : si la valeur de la cellule change de A à B puis revient à A, CAS pensera qu’il n’y a pas eu de changement. Pour résoudre ce problème, on utilise des classes comme AtomicStampedReference ou AtomicMarkableReference.
• Il peut y avoir beaucoup d’échecs (boucles de spin) en forte concurrence.