Для чего нужно ключевое слово volatile в Java? Объясните с примерами

Что такое volatile и как он решает проблему видимости переменных

Ключевое слово volatile в Java решает проблему видимости изменений переменной между потоками. Ваш пример — классический случай, когда без volatile программа может зависнуть. Давайте разберёмся, почему это происходит.

Как Java работает с памятью в многопоточности

Каждый поток может кешировать значение переменной в своём регистре процессора или в локальном кеше (L1/L2 кеш ядра CPU). Это делается для производительности — чтобы не обращаться каждый раз к основной памяти (RAM), которая работает медленнее. Когда поток изменяет переменную, новое значение может остаться только в его локальном кеше и не сразу записаться в основную память. Другой поток, читая ту же переменную, может получить устаревшее значение из своего кеша.

В вашем примере:

• Поток worker читает running в цикле while (running). JIT-компилятор может оптимизировать этот цикл: он видит, что running не меняется внутри цикла, и загружает его значение в регистр один раз. После этого он бесконечно проверяет регистр, не заглядывая в память.
• Главный поток устанавливает running = false, записывая новое значение в основную память (или в свой кеш). Но worker-поток этого не видит, так как продолжает читать из регистра.

Как volatile решает проблему

Когда вы объявляете поле как volatile:

private static volatile boolean running = true;

Java гарантирует два важных поведения:

1. Запись в volatile-переменную сразу же сбрасывается в основную память (RAM), а не остаётся в кеше потока.
2. Чтение volatile-переменной всегда происходит из основной памяти, а не из локального кеша. Любые кешированные значения становятся недействительными.

Таким образом, когда главный поток пишет running = false, это значение немедленно становится видимым для всех других потоков. Worker-поток при следующей итерации цикла прочитает актуальное значение из основной памяти и корректно завершится.

Когда использовать volatile, а когда — другие механизмы

volatile подходит для простых флагов состояния, когда:

• Только один поток изменяет переменную, а остальные только читают.
• Операция с переменной атомарна (например, запись или чтение boolean, int, ссылки на объекты).
• Вам не нужна блокировка — вы просто хотите гарантировать видимость изменений.

Когда volatile НЕ подходит:

• Если несколько потоков изменяют одну переменную (например, инкремент count++). Операция count++ не атомарна — это три действия: чтение, увеличение, запись. volatile не защитит от состояния гонки. В этом случае используйте synchronized или AtomicInteger.
• Если вам нужна атомарность составных действий (например, проверка-и-изменение). Тут требуется synchronized или Lock.

Пример с AtomicBoolean

Для вашего случая с флагом можно использовать AtomicBoolean, который тоже гарантирует видимость и предоставляет атомарные методы:

import java.util.concurrent.atomic.AtomicBoolean;

public class TestAtomic {
    private static AtomicBoolean running = new AtomicBoolean(true);

    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            while (running.get()) {
                // работаем
            }
            System.out.println("Worker остановлен");
        });
        worker.start();

        Thread.sleep(1000);
        running.set(false);
        System.out.println("Флаг установлен в false");
    }
}

Дополнительно: happens-before гарантии

volatile создаёт отношение happens-before между записью и последующим чтением. Это означает, что все изменения, сделанные потоком до записи в volatile-переменную, также становятся видимыми для потока, который читает эту переменную. Например:

private static volatile boolean ready;
private static int data;

// Поток 1
data = 42;          // (1)
ready = true;       // (2) — volatile запись

// Поток 2
if (ready) {        // (3) — volatile чтение
    System.out.println(data); // гарантированно увидит 42
}

Без volatile поток 2 мог бы увидеть ready = true, но data осталось бы 0 из-за переупорядочивания инструкций компилятором или процессором.

Итог: Используйте volatile для простых флагов состояния, которые изменяются одним потоком и читаются другими. Для счётчиков и сложной логики применяйте атомарные классы или синхронизацию.

private static volatile int counter = 0;

// В 10 потоках выполняем:
for (int i = 0; i < 1000; i++) {
    counter++; // НЕ атомарно!
}

System.out.println(counter); // Может быть не 10000, а меньше

private static volatile Singleton instance;

public static Singleton getInstance() {
    if (instance == null) {
        synchronized (Singleton.class) {
            if (instance == null) {
                instance = new Singleton();
            }
        }
    }
    return instance;
}