В чем разница между атомарным типом и volatile?

# Разница между атомарным типом (Atomic) и volatile в Java

Оба используются для многопоточного программирования, но решают разные проблемы:

Краткая таблица

volatile - Видимость без атомарности

volatile гарантирует, что изменения одного потока видны другим потокам.

Проблема без volatile:

public class VisibilityProblem {
    private boolean flag = false;  // Обычная переменная
    
    public void writerThread() {
        flag = true;  // Поток 1 пишет
    }
    
    public void readerThread() {
        while (!flag) {  // Поток 2 читает
            // Может зависнуть навечно!
            // Поток 2 не видит изменения flag в своём кэше процессора
        }
    }
}

Решение с volatile:

public class VisibilitySolution {
    private volatile boolean flag = false;  // Добавляем volatile
    
    public void writerThread() {
        flag = true;  // Пишет в main memory (не в кэш)
    }
    
    public void readerThread() {
        while (!flag) {  // Читает из main memory
            // Теперь видит изменения!
        }
    }
}

Как работает volatile:

1. При записи в volatile переменную:

   • Значение пишется в main memory (системную память)
   • Кэш других потоков инвалидируется
   • Последующие действия не реордерируются

2. При чтении из volatile переменной:

   • Значение читается из main memory
   • Предыдущие действия завершены
   • Следующие действия не начинаются раньше

Пример: простой флаг:

public class Shutdown {
    private volatile boolean shutdown = false;
    
    public void shutdown() {
        shutdown = true;  // Все потоки видят это
    }
    
    public void runLoop() {
        while (!shutdown) {  // Постоянно проверяем из main memory
            // Работаем
        }
    }
}

Ограничение volatile:

private volatile int counter = 0;

// ❌ НЕ АТОМАРНО! Race condition
public void increment() {
    counter++;  // Это 3 операции: read, increment, write
    // Два потока могут:  
    // Поток 1: read (0) → increment (1) → write
    // Поток 2: read (0) → increment (1) → write
    // Результат: 1, а не 2!
}

// ✅ ПРАВИЛЬНО: использовать synchronized
public synchronized void increment() {
    counter++;
}

Atomic - Видимость + Атомарность

AtomicInteger, AtomicLong, AtomicReference и т.д. гарантируют атомарные операции без блокировок.

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

public class AtomicInteger {
    private volatile int value;  // Внутри тоже volatile!
    
    // Атомарное увеличение (lock-free, использует CAS)
    public final int incrementAndGet() {
        for (;;) {  // Бесконечный цикл
            int current = get();
            int next = current + 1;
            // Compare-And-Swap: если value == current, установи next
            if (compareAndSet(current, next))
                return next;
            // Если изменилось, повторяй цикл
        }
    }
    
    // Атомарное сравнение и установка (CAS)
    public final boolean compareAndSet(int expect, int update) {
        // Это аппаратная операция (CPU инструкция)
        return compareAndSetIntrinsic(expect, update);
    }
}

Пример: безопасный счётчик:

public class CounterWithAtomic {
    private AtomicInteger counter = new AtomicInteger(0);
    
    // ✅ АТОМАРНО!
    public void increment() {
        counter.incrementAndGet();  // Безопасно для многопоточности
    }
    
    public int getValue() {
        return counter.get();
    }
}

// Использование
CounterWithAtomic counter = new CounterWithAtomic();
for (int i = 0; i < 1000; i++) {
    new Thread(() -> {
        for (int j = 0; j < 1000; j++) {
            counter.increment();  // 1 млн инкрементов
        }
    }).start();
}
System.out.println(counter.getValue());  // Гарантировано 1000000

Типичные Atomic классы:

import java.util.concurrent.atomic.*;

// Примитивные типы
AtomicInteger ai = new AtomicInteger(0);
ai.incrementAndGet();      // 1
ai.decrementAndGet();      // 0
ai.addAndGet(5);           // 5
ai.getAndIncrement();      // 5 (возвращает старое значение)

AtomicLong al = new AtomicLong(0);
AtomicBoolean ab = new AtomicBoolean(false);

// Ссылки на объекты
AtomicReference<String> ref = new AtomicReference<>("initial");
ref.set("new value");
ref.compareAndSet("new value", "updated");  // Атомарно!

// Массивы
AtomicIntegerArray arr = new AtomicIntegerArray(new int[10]);
arr.incrementAndGet(0);  // Атомарно увеличить элемент [0]

Практическое сравнение

Сценарий 1: простой флаг отключения

// volatile достаточно - нужна только видимость
public class Service {
    private volatile boolean running = true;
    
    public void shutdown() {
        running = false;  // Все потоки видят
    }
    
    public void run() {
        while (running) {  // Проверяем часто
            // Работа
        }
    }
}

Сценарий 2: счётчик обращений

// Atomic нужен - требуется атомарность
public class RequestCounter {
    private AtomicLong count = new AtomicLong(0);
    
    public void incrementCount() {
        count.incrementAndGet();  // Атомарно!
    }
    
    public long getCount() {
        return count.get();
    }
}

// В тысячах потоков одновременно - счёт точен

Сценарий 3: обновление ссылки

// AtomicReference для безопасного обновления ссылки
public class Config {
    private AtomicReference<ConfigData> config = new AtomicReference<>();
    
    public void updateConfig(ConfigData newConfig) {
        config.set(newConfig);  // Видимо другим потокам
    }
    
    public ConfigData getConfig() {
        return config.get();  // Видим последние изменения
    }
    
    // Обновить только если текущее значение совпадает
    public boolean tryUpdateConfig(ConfigData oldConfig, ConfigData newConfig) {
        return config.compareAndSet(oldConfig, newConfig);
    }
}

Производительность

// Benchmark: 10M инкрементов

// synchronized - медленно (~2000ms)
private int counter = 0;
public synchronized void increment() {
    counter++;
}

// volatile (неправильно!) - race condition
private volatile int counter = 0;
public void increment() {
    counter++;  // ❌ Не безопасно!
}

// AtomicInteger - быстро (~100ms)
private AtomicInteger counter = new AtomicInteger(0);
public void increment() {
    counter.incrementAndGet();
}

// Вывод: AtomicInteger в 20 раз быстрее synchronized!

Memory Ordering

Оба обеспечивают правильный порядок операций:

// Пример: Double-Checked Locking с volatile
class Singleton {
    private volatile Singleton instance;  // volatile для видимости!
    
    public Singleton getInstance() {
        if (instance == null) {           // Первая проверка (быстро)
            synchronized (this) {
                if (instance == null) {   // Вторая проверка (безопасно)
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

// Без volatile: другой поток может видеть недоинициализированный объект!

Выбор между volatile и Atomic

Используй volatile когда:

1. Простая видимость: флаги, состояния
2. Чтение часто, запись редко: мониторинг
3. Операция одна: read или write
4. Максимальная производительность: нет CAS цикла

private volatile boolean stopped = false;
private volatile long lastUpdate = System.currentTimeMillis();

Используй Atomic когда:

1. Сложные операции: increment, swap
2. Race condition вероятны: счётчики
3. Нужна атомарность: обновление с проверкой
4. Количество потоков велико: Lock-free быстрее

private AtomicInteger requestCount = new AtomicInteger(0);
private AtomicReference<User> currentUser = new AtomicReference<>();

Итоговое резюме

volatile:

• Гарантирует видимость между потоками
• Не гарантирует атомарность
• Используй для флагов и состояний
• Быстрее (no CAS loop)
• ❌ Не используй для increment/decrement

Atomic:

• Гарантирует видимость AND атомарность
• Lock-free (используется CAS)
• Используй для счётчиков и обновлений
• Медленнее чем volatile (но быстрее чем synchronized)
• ✅ Правильный выбор для сложных операций

Золотое правило: volatile для видимости, Atomic для атомарных операций