Эффективный и современный С++. 42 рекомендации по использованию С++11 и С++14 - [118]

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

Возможность С++, которую программисты периодически путают с volatile и которая, безусловно, относится к данной главе, — это шаблон std::atomic. Инстанцирования этого шаблона (например, std::atomic, std::atomic, std::atomic и т.п.) предоставляют операции, которые другими потоками будут гарантированно восприниматься как атомарные. После создания объекта std::atomic операции над ним ведут себя так, как будто они выполняются внутри критического раздела, защищенного мьютексом, но эти операции обычно реализуются с помощью специальных машинных команд, которые значительно эффективнее применения мьютексов. Рассмотрим код с применением std::atomic:

std::atomic ai(0); // Инициализация ai значением 0
ai = 10;                // Атомарное присваивание ai значения 10
std::cout << ai;        // Атомарное чтение значения ai
++ai;                   // Атомарный инкремент ai до 11
--ai;                   // Атомарный декремент ai до 10

В процессе выполнения данных инструкций другие потоки, читающие ai, могут увидеть только значения 0, 10 и 11. Никакие другие значения невозможны (конечно, в предположении, что это единственный поток, модифицирующий ai).

Следует отметить два аспекта этого примера. Во-первых, в инструкции “std::cout << ai;” тот факт, что ai представляет собой std::atomic, гарантирует только то, что атомарным является чтение ai. Нет никакой гарантии атомарности всей инструкции. Между моментом чтения значения ai и вызовом оператора operator<< для записи в поток стандартного вывода другой поток может изменить значение ai. Это не влияет на поведение инструкции, поскольку operator<< для int использует передачу выводимого параметра типа int по значению (таким образом, выведенное значение будет тем, которое прочитано из ai), но важно понимать, что во всей этой инструкции атомарным является только чтение значения ai.

Второй важный аспект этого примера заключается в поведении двух последних инструкций — инкремента и декремента ai. Каждая из этих операций является операцией чтения-изменения-записи (read-modify-write — RMW), выполняемой атомарно. Это одна из приятнейших характеристик типов std::atomic: если объект std::atomic создан, все его функции-члены, включая RMW-операции, будут гарантированно рассматриваться другими потоками как атомарные.

В противоположность этому такой же код, но использующий квалификатор volatile, в многопоточном контексте не гарантирует почти ничего:

volatile vi(0);  // Инициализация vi значением 0
vi = 10;         // Присваивание vi значения 10
std::cout << vi; // Чтение значения vi
++vi;            // Инкремент vi до 11
--vi;            // Декремент vi до 10

Во время выполнения этого кода, если другой поток читает значение vi, он может прочесть что угодно, например -12, 68, 4090727, — любое значение! Такой код обладает неопределенным поведением, потому что эти инструкции изменяют vi, и если другие потоки читают vi в тот же момент времени, то эти одновременные чтения и записи памяти не защищены ни std::atomiс, ни с помощью мьютексов, а это и есть определение гонки данных.

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

std::atomic ас(0); // "счетчик atomic"
volatile int vc(0);     // "счетчик volatile"

Затем увеличим каждый счетчик по разу в двух одновременно работающих потоках:

/*----- Поток 1------ */ /*----- Поток 2 ------ */
        ++ас;                    ++ас;
        ++vc;                    ++vc;

По завершении обоих потоков значение ас (т.e. значение std::atomic) должно быть равно 2, поскольку каждый инкремент осуществляется как атомарная, неделимая операция. Значение vc, с другой стороны, не обязано быть равным 2, поскольку его инкремент может не быть атомарным. Каждый инкремент состоит из чтения значения vc, увеличения прочитанного значения и записи результата обратно в vc. Но для объектов volatile не гарантируется атомарность всех трех операций, так что части двух инкрементов vc могут чередоваться следующим образом.

1. Поток 1 считывает значение vc, равное 0.

2. Поток 2 считывает значение vc, все еще равное 0.

3. Поток 1 увеличивает 0 до 1 и записывает это значение в vc.

4. Поток 1 увеличивает 0 до 1 и записывает это значение в vc.

Таким образом, окончательное значение vc оказывается равным 1, несмотря на два инкремента.

Это не единственный возможный результат. В общем случае окончательное значение vc непредсказуемо, поскольку переменная vc включена в гонку данных, а стандарт однозначно утверждает, что гонка данных ведет к неопределенному поведению; это означает, что компиляторы могут генерировать код, выполняющий буквально все что угодно. Конечно, компиляторы не используют эту свободу для чего-то вредоносного. Но они могут выполнить оптимизации, вполне корректные при отсутствии гонки данных, и эти оптимизации приведут к неопределенному и непредсказуемому поведению при наличии гонки данных.