Зачем нужно ключевое слово volatile в C++? Объясните на примерах

Что такое volatile и зачем он нужен

Ключевое слово volatile в C++ — это указание компилятору: "Не оптимизируй этот объект! Его значение может измениться в любой момент без ведома компилятора". Обычно компилятор активно оптимизирует код: удаляет "лишние" чтения/записи, переупорядочивает инструкции, заменяет переменные константами. Но в некоторых ситуациях это ломает логику программы.

Типичные сценарии использования

• Работа с аппаратурой (memory-mapped I/O) — регистры устройств (GPIO, UART, таймеры).
• Обработчики прерываний (ISR) — переменная изменяется в прерывании, а читается в основном коде.
• Сигналы (signal handlers) — глобальный флаг, изменяемый обработчиком сигнала.

Пример 1: Бесконечный цикл без volatile

// Без volatile — UB или бесконечный цикл
bool flag = false;

void interrupt_handler() { // допустим, вызывается по прерыванию
    flag = true;
}

int main() {
    while (!flag) { } // компилятор может превратить в while(true)
    // Работа с устройством
}

Компилятор видит: flag не меняется в цикле. Он оптимизирует: загружает flag в регистр один раз и проверяет его вечно. volatile запрещает эту оптимизацию:

volatile bool flag = false; // теперь каждое чтение — из памяти

Пример 2: Регистр устройства

// Адрес регистра статуса UART (вымышленный)
#define UART_STATUS (*(volatile uint32_t*)0x40004000)

void send_byte(char c) {
    // Ждём, пока устройство не будет готово
    while (UART_STATUS & 0x01 == 0) { }
    // Отправляем байт
    *(volatile uint32_t*)0x40004004 = c;
}

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

Важно: volatile ≠ thread-safe

Многие думают, что volatile помогает в многопоточности. Это не так! volatile не гарантирует атомарности операций и не обеспечивает правильный порядок видимости между потоками. Для многопоточности используйте std::atomic или мьютексы.

Отличия volatile от std::atomic

• volatile — запрещает оптимизацию чтений/записей, но не даёт атомарности (например, ++volatile_int — не атомарно).
• std::atomic — гарантирует атомарность и упорядочивание памяти (memory ordering). Подходит для многопоточности.
• volatile — для работы с железом и прерываниями (один поток + аппаратура).

Пример: Неправильное использование volatile в многопоточности

volatile int counter = 0;

// Поток 1
void thread1() {
    for (int i = 0; i < 1000; ++i)
        ++counter; // НЕ атомарно! Может быть race condition
}

// Поток 2
void thread2() {
    for (int i = 0; i < 1000; ++i)
        ++counter; // То же самое
}

Правильный вариант: std::atomic<int> counter{0};

Когда использовать volatile (резюме)

• Только при работе с аппаратными регистрами (memory-mapped I/O).
• Для флагов между основным кодом и обработчиком прерывания (в одном ядре).
• В signal handlers (POSIX) — для глобальных флагов типа volatile std::sig_atomic_t.
• Никогда для синхронизации потоков — используйте std::atomic.

В современном C++ (C++11 и новее) volatile практически вытеснен из многопоточного программирования. Его основная ниша — низкоуровневое взаимодействие с железом и легаси-код.

volatile int reg = 0;
reg = 1; // обязательно запись в память
reg = 2; // тоже запись (не может удалить "лишнюю")
int a = reg; // чтение
int b = reg; // ещё одно чтение (не может заменить на b = a)