Являются ли +=, |=, &= и т. д. атомарными?

Ты неправ. Нет никакой гарантии, что ++ является атомарным, равно как и для составных операторов присваивания, да и вообще для любой операции C++.

x++ часто реализуется в виде 3 инструкций: прочитать X в регистр, увеличить его и записать обратно в память.

Ваш поток может быть вытеснен между любым из них.

Чтобы изменение значения было видно между ядрами, += (например) должно загрузить значение, добавить приращение и затем сохранить его. Это означает, что операция не будет атомарной.

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

Нет, они не атомарные! Если вам нужны атомарные операции над примитивными типами и вы используете Linux, вы можете посмотреть здесь: http://gcc.gnu.org/onlinedocs/gcc-4.1.0/gcc/Atomic-Builtins.html и/или atomic.h...

++ может быть атомарным на вашем компиляторе/платформе, но в спецификациях С++ он не определен как атомарный.

Если вы хотите убедиться, что значение изменено атомарно, вам следует использовать соответствующие методы, такие как Interlocked* в Windows.

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

Ни один оператор в C или C++ не может быть атомарным. Они могут быть на вашей платформе, но вы не будете знать наверняка. Как правило, единственной атомарной операцией является инструкция Test and Set, которая обычно доступна на большинстве современных процессоров в той или иной форме в качестве основы для реализации семафоров.

Это зависит как от компилятора, так и от процессора. Некоторые наборы инструкций предоставляют для них атомарные инструкции (для целых чисел машинного размера).

Однако нет никакой гарантии, что ваш компилятор будет использовать эти инструкции и не оптимизирует ваш код небезопасным для потоков способом. Вам нужно либо написать подпрограмму на ассемблере, либо использовать специальную технику компилятора (например, instrinsics), которая обеспечивает атомарность (или использовать библиотеку, которая использует одну из этих техник).

В частности, для ARM: инструкции ORR/ADD/AND принимают два операнда и помещают результат в регистр. Любой операнд может быть тем же регистром, что и регистр результата, поэтому их можно использовать как атомарные |=, +=, &=.

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

Они не только не атомарны, как все операции, но и могут давать очень интересные результаты. Например, если компилятор видит, что он записывает в x, ему разрешено использовать x как временную переменную, а не занимать регистры вверх или пространство стека. Это означает, что x может временно содержать ЛЮБОЕ значение, а не только значения, которые имеют смысл для x.

http://software.intel.com/en-us/blogs/2013/01/06/benign-data-races-what-could-possently-go-wrong

Сюда направлен дубликат, и его необходимо обновить. «Новый» язык C11 включает атомарный атрибут, который допускает, что:

_Atomic int a;
...
a += 3

может быть скомпилирован в (атомарный) неограниченный цикл. Спасибо за стандарты подарков, я бы очень хотел, чтобы вы этого не делали.

1: в некоторых архитектурах атомарные операции возможны только с памятью, которая поддерживает определенные протоколы доступа. ARMv7, MIPS, например, превращают последовательность в:

do {
    x = LoadLinked(a) + 3;
} while !StoreConditional(x, &a);

но LoadLinked/StoreConditional не определен для некоторых типов памяти/кэша. Наслаждайтесь отладкой этого.

2: Связано с этим ложное совместное использование, которое является артефактом LoadLinked, StoreConditional, работающего со строками кэша (например, 32, 64, 256 байт), а не с подблоками. Итак: _Atomic int a[4]; может потребоваться размер строки кэша 4 * (таким образом, 1024 байта), чтобы безопасно разрешить одновременные атомарные операции с [n] и [n + 1], потому что 4 процессора могут бороться за обновление [0..3], но никогда не удается .

Будем надеяться, что следующий стандарт признает врожденную неудачу оформления атрибутов и восстановит c89 в качестве законного стандарта C.

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

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

Вы должны защитить свою переменную, например, с помощью мьютекса