Mi az a CAS (Compare-And-Swap) mechanizmus?

A Compare-And-Swap (CAS) mechanizmus egy atomikus gépi művelet, amit a zárolás nélküli szinkronizáció megvalósítására használnak.

Működési elv:

1. Olvassa a memória cella aktuális értékét (expectedValue).
2. Megpróbálja írni az új értéket (newValue) ebbe a cellába csak akkor, ha az aktuális érték megegyezik az expectedValue-val.
3. Visszaad egy logikai értéket: true, ha a írás sikeres volt (azaz egyezés volt), false különben.

Java-ban a CAS a java.util.concurrent.atomic csomag osztályaiban van megvalósítva, például AtomicInteger, AtomicLong, AtomicReference.

Példa az AtomicInteger használatára:

// 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(); // Aktuális érték olvasása
            int newValue = expectedValue + 1;
            if (count.compareAndSet(expectedValue, newValue)) {
                // Ha az aktuális érték nem változott az olvasás óta,
                // végrehajtja az írást és kilép a ciklusból
                break;
            }
            // Ha az érték változott, újra próbálja
        }
    }
}

Előnyök:

• Nem blokkoló: a szálak nem blokkolják egymást, csökkentve a kontextusváltási költségeket, különösen alacsony verseny esetén.
• Elkerüli a deadlock problémákat.

Hátrányok:

• ABA probléma: ha a cella értéke A-ról B-re változik, majd vissza A-ra, a CAS azt fogja hinni, hogy nem történt változás. Ennek megoldására olyan osztályokat használnak, mint az AtomicStampedReference vagy az AtomicMarkableReference.
• Magas verseny esetén sok sikertelen próbálkozás (spin loop) fordulhat elő.