Эффективный и современный С++. 42 рекомендации по использованию С++11 и С++14 - [118]
Возможность С++, которую программисты периодически путают с >volatile и которая, безусловно, относится к данной главе, — это шаблон >std::atomic. Инстанцирования этого шаблона (например, >std::atomic, >std::atomic, >std::atomic и т.п.) предоставляют операции, которые другими потоками будут гарантированно восприниматься как атомарные. После создания объекта >std::atomic операции над ним ведут себя так, как будто они выполняются внутри критического раздела, защищенного мьютексом, но эти операции обычно реализуются с помощью специальных машинных команд, которые значительно эффективнее применения мьютексов. Рассмотрим код с применением >std::atomic:
>std::atomic
>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
>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 включена в гонку данных, а стандарт однозначно утверждает, что гонка данных ведет к неопределенному поведению; это означает, что компиляторы могут генерировать код, выполняющий буквально все что угодно. Конечно, компиляторы не используют эту свободу для чего-то вредоносного. Но они могут выполнить оптимизации, вполне корректные при отсутствии гонки данных, и эти оптимизации приведут к неопределенному и непредсказуемому поведению при наличии гонки данных.
