Что такое CAS?

Что такое CAS

CAS (Compare-And-Swap) — это атомарная операция, которая позволяет безопасно изменять значение переменной в многопоточной среде без использования явных блокировок (locks). Это основной механизм оптимистичной синхронизации в Java.

Как работает CAS

CAS берёт три параметра:

1. Текущее значение (expectedValue) — то, что мы ожидаем найти
2. Новое значение (newValue) — что мы хотим установить
3. Переменная — что мы изменяем

Алгоритм:

• Если текущее значение в памяти == expectedValue, то установить newValue и вернуть true
• Если текущее значение != expectedValue, то ничего не менять и вернуть false

Всё это происходит атомарно (неделимо) на уровне процессора благодаря инструкции CMPXCHG.

Пример использования

import java.util.concurrent.atomic.AtomicInteger;

public class CASExample {
    private AtomicInteger counter = new AtomicInteger(0);
    
    public void increment() {
        // compareAndSet(expectedValue, newValue)
        // Пока не удастся обновить счётчик
        int current;
        do {
            current = counter.get();
        } while (!counter.compareAndSet(current, current + 1));
    }
    
    public static void main(String[] args) throws InterruptedException {
        CASExample example = new CASExample();
        
        // 10 потоков увеличивают счётчик
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    example.increment();
                }
            });
            threads[i].start();
        }
        
        for (Thread t : threads) {
            t.join();
        }
        
        System.out.println("Counter: " + example.counter.get()); // 10000
    }
}

Преимущества CAS

• Нет блокировок — избегаем deadlock и потери производительности на ожидание
• Высокая пропускная способность — много потоков работают параллельно без конкуренции за lock
• Кэш-дружелюбность — нет дорогостоящих операций синхронизации между ядрами

Недостатки CAS

• ABA проблема — если значение изменилось A → B → A, CAS не заметит промежуточные изменения
• Spin-loop — в случае конфликтов поток крутится в цикле, тратя CPU
• Fairness — нет гарантии справедливости, один поток может доминировать

Где используется CAS в Java

// AtomicInteger, AtomicLong, AtomicReference
AtomicInteger ai = new AtomicInteger(5);
ai.compareAndSet(5, 10);      // true
ai.compareAndSet(5, 15);      // false (значение уже 10)

// AtomicStampedReference защищает от ABA проблемы
AtomicStampedReference<String> ref = 
    new AtomicStampedReference<>("A", 0);
ref.compareAndSet("A", "B", 0, 1); // версионирование

CAS в Java Memory Model

CAS гарантирует:

• Visibility — все потоки видят актуальное значение
• Atomicity — операция не может быть прервана
• Ordering — consistent ordering с other happens-before rules

Это фундамент для lock-free структур данных (ConcurrentHashMap, CopyOnWriteArrayList) и функционального программирования в Java (immutable + CAS).