Решает ли volatile проблему race condition?

Ключевое слово volatile в Java обеспечивает две важные гарантии: видимость и запрет переупорядочивания. Видимость означает, что любое изменение значения volatile-переменной одним потоком немедленно становится видимым для всех других потоков. Запрет переупорядочивания не позволяет компилятору и процессору менять порядок операций вокруг чтения/записи volatile-переменной, что важно для корректной работы некоторых многопоточных паттернов.

Что такое race condition?

Race condition (состояние гонки) — это ошибка, возникающая, когда результат выполнения программы зависит от порядка или времени выполнения потоков. Классический пример — инкремент общей переменной несколькими потоками. Операция инкремента (counter++) не является атомарной: она состоит из чтения значения, увеличения и записи. Если два потока одновременно читают одно и то же значение, увеличивают его и записывают, одно из увеличений будет потеряно.

Почему volatile недостаточно?

Объявление переменной как volatile не делает операции над ней атомарными. Оно гарантирует, что потоки увидят актуальное значение переменной, но не предотвращает ситуацию, когда два потока одновременно выполняют неатомарные шаги. Таким образом, volatile решает проблему видимости устаревших данных (кэшированных в регистрах процессора), но не решает проблему атомарности составных операций.

Пример кода

public class CounterExample {
    private volatile int count = 0;

    public void increment() {
        // Это НЕ безопасно, несмотря на volatile!
        count++; // Неатомарная операция: read-modify-write
    }

    public int getCount() {
        return count;
    }
}

В этом примере, даже если count объявлен как volatile, метод increment не является потокобезопасным. Несколько потоков, вызывающих increment одновременно, могут привести к потере некоторых инкрементов.

Как правильно решить проблему?

Для обеспечения атомарности и устранения race condition следует использовать:

• Синхронизированные блоки или методы (synchronized): Гарантируют, что только один поток может выполнять критическую секцию в данный момент.
• Атомарные классы (AtomicInteger, AtomicLong и др.): Предоставляют атомарные операции, такие как incrementAndGet(), используя низкоуровневые механизмы процессора (CAS — compare-and-swap).
• Примитивы из пакета java.util.concurrent: Например, ReentrantLock.

Пример исправленного кода с AtomicInteger:

import java.util.concurrent.atomic.AtomicInteger;

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

    public void increment() {
        count.incrementAndGet(); // Атомарная операция
    }

    public int getCount() {
        return count.get();
    }
}

Вывод: Ключевое слово volatile полезно для флагов завершения работы или однократной инициализации (например, в шаблоне Double-Checked Locking), но оно не является инструментом для решения race condition при выполнении составных операций. Для обеспечения потокобезопасности при совместной модификации данных необходимо использовать механизмы, гарантирующие атомарность.