Какие гарантии дает volatile

Гарантии volatile в Java

volatile — это модификатор переменной, который обеспечивает несколько критически важных гарантий для работы с многопоточностью. Это не синхронизация, а именно гарантии видимости и упорядочения операций в памяти.

Основные гарантии volatile

1. Видимость (Visibility)

Гарантирует, что запись в volatile переменную одним потоком становится видна всем остальным потокам немедленно:

private volatile boolean flag = false;

public void setFlag() {
    flag = true;  // Запись видна всем потокам
}

public void checkFlag() {
    if (flag) {  // Прочитаем свежее значение из памяти
        // Действие
    }
}

Без volatile компилятор/процессор может кэшировать значение в регистре потока, и другие потоки увидят устаревшие данные.

2. Happens-Before отношение

volatile создаёт happens-before отношение между операциями:

• Запись в volatile happens-before любым последующим чтениям этой переменной
• Это гарантирует упорядочение операций памяти

private volatile boolean ready = false;
private int value = 0;

public void setup() {
    value = 42;      // Операция 1
    ready = true;    // Операция 2 (volatile write)
}

public void consume() {
    if (ready) {     // volatile read
        System.out.println(value);  // ГАРАНТИРОВАННО выведет 42
    }
}

Гарантировано, что value = 42 выполнится ДО ready = true, и другой поток прочитает актуальное значение.

3. Запрет переупорядочивания операций

Компилятор и процессор не могут менять порядок операций относительно volatile:

private volatile boolean stop = false;
private List<String> data = new ArrayList<>();

public void producer() {
    data.add("item1");    // Операция 1
    data.add("item2");    // Операция 2
    stop = true;          // volatile write — барьер памяти
}

public void consumer() {
    if (stop) {           // volatile read — барьер памяти
        System.out.println(data);  // Гарантированно видим обе операции
    }
}

Что volatile НЕ гарантирует

Важно понимать ограничения:

❌ Атомарность составных операций

private volatile int counter = 0;

public void increment() {
    counter++;  // ⚠️ НЕ АТОМАРНА! Три операции: read, modify, write
}

Это некорректно для многопоточной среды. Нужен AtomicInteger:

private AtomicInteger counter = new AtomicInteger(0);

public void increment() {
    counter.incrementAndGet();  // ✅ Атомарно
}

❌ Защита от одновременного доступа к объекту

private volatile List<String> list = new ArrayList<>();

public void unsafeAdd(String item) {
    list.add(item);  // ⚠️ НЕ ПОТОКОБЕЗОПАСНО!
    // volatile гарантирует видимость ссылки, не самого списка
}

❌ Взаимное исключение (Mutual Exclusion)

volatile не блокирует доступ, не может заменить synchronized.

Примеры корректного использования

Флаги завершения потока

private volatile boolean running = true;

public void run() {
    while (running) {
        doWork();
    }
}

public void shutdown() {
    running = false;  // Поток корректно остановится
}

Ленивая инициализация (Double-Checked Locking)

private volatile Singleton instance;

public Singleton getInstance() {
    if (instance == null) {  // Первая проверка (не заблокирована)
        synchronized(this) {
            if (instance == null) {  // Вторая проверка
                instance = new Singleton();
            }
        }
    }
    return instance;
}

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

Конфигурация (immutable after write)

private volatile Map<String, String> config;

public void loadConfig(Map<String, String> newConfig) {
    config = newConfig;  // volatile write
}

public String getConfig(String key) {
    return config.get(key);  // volatile read
}

Сравнение с альтернативами

Внутренний механизм

Под капотом volatile использует:

• Memory barriers (барьеры памяти) — инструкции процессора
• На x86: LOCK префикс для записей
• На ARM: DMB (Data Memory Barrier) инструкции
• Предотвращают переупорядочивание операций в памяти

Итоговые рекомендации

✅ Используй volatile для:

• Простых флагов (boolean)
• Ленивой инициализации (с DCL)
• Конфигурации, которая не меняется часто
• Когда нужна видимость, но не нужна атомарность

❌ Не используй volatile для:

• Счётчиков и операций read-modify-write → AtomicInteger
• Нескольких взаимосвязанных переменных → synchronized
• Сложной синхронизации → ReentrantLock, CountDownLatch