Что хотят услышать интервьюеры:

volatile не делает операции атомарными и не заменяет синхронизацию, но гарантирует видимость изменений между потоками. Также оно задаёт ограничения на переупорядочивание: чтения и записи вокруг volatile не могут свободно переставляться. Через это volatile напрямую связано с моделью Happens-before: запись в volatile происходит-before последующее чтение этого же поля.

Определение:

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

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

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

class Worker {
    private volatile boolean stopped = false;

    public void stop() {
        stopped = true; // запись в volatile
    }

    public void run() {
        while (!stopped) { // чтение volatile
            // выполняем работу
        }
    }
}

Здесь один поток устанавливает флаг остановки, а другой поток корректно увидит это изменение без synchronized.

Пояснение кода:

Код показывает типичный сценарий сигнального флага между потоками.

Поток управления вызывает stop() и пишет true в stopped.
Поскольку stopped объявлен как volatile, это изменение немедленно становится видимым другим потокам.
Поток в run() постоянно перечитывает значение stopped из основной памяти/с учётом гарантий JVM.
Как только значение становится true, цикл завершается.

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

volatile также создаёт порядок: все операции в потоке до записи stopped = true будут видны после того, как другой поток прочитает stopped == true. Но если бы вместо флага обновлялся, например, счётчик через count++, volatile не сделал бы это действие атомарным.

Ключевые моменты:

volatile гарантирует видимость изменений между потоками.
volatile гарантирует порядок относительно самого volatile-доступа за счёт ограничений на переупорядочивание.
Запись в volatile happens-before последующего чтения того же поля.
volatile не гарантирует атомарность составных операций.
Для инкремента, проверки-then-act и сложных критических секций нужен synchronized, Lock или атомарные классы.
На практике volatile хорошо подходит для флагов состояния, публикации ссылок и простых сигналов между потоками.

Является ли ключевое слово volatile гарантией порядка выполнения операций в многопоточной среде и как оно связано с моделью Happens-before?