Les opérations atomiques imbriquées sont-elles garanties atomiques?

Question

Excuses si cela a déjà été répondu, ou si quelque chose me manque.

J'essaie de comprendre à quel point les garanties de l'atomicité vont de std::atomic. Par exemple, si nous avons

std::atomic<int> a(0); 
a.store(1); 

l'opération de stockage est atomique. Cependant, ce qui se passe si nous avons imbriqué des opérations atomiques, comme ceci:

std::atomic<int> a(0); 
std::atomic<int> b(1); 
a.store(++b); 

Ma compréhension est que ++b est atomique, et est donc store(). Ai-je raison de supposer que cela est garanti de stocker 2 atomiquement dans a?

Plus important encore, si a et b sont partagés entre les fils T1 et T2, est-il garanti que a.store(++b); effectué par les deux fils va stocker la valeur incrémentée de b (comme on le voit par les fils respectifs) dans a atomiquement dans chaque fil? En d'autres termes, peut enfiler T2 « bout à bout dans » et incrémenter b une fois de plus aprèsT1 a déjà incrémentée une fois, mais avant le résultat est stocké dans a par T1?

Answer 1

L'incrément est atomique et le stockage est atomique, mais les deux opérations ne le sont pas. Il est possible que le premier thread incrémente b, soit suspendu, puis un autre thread incrémente b et stocke cette valeur dans a, puis le premier thread reprend et stocke sa valeur (maintenant périmée) de b en a.

Answer 2

L'atomicité ne comprend pas.

En supposant que personne d'autre écrit jamais a et b et un autre thread essaie de lire à la fois après qu'ils existent, et ils lisent b alors a, lit possible sont exactement:

{b,a} 
{1,0} 
{2,0} 
{2,2} 

s'ils lisent a puis b:

{a,b} 
{0,1} 
{0,2} 
{2,2} 

qui dans ce cas est le même que b puis a.

Answer 3

a.store(++b); 

est équivalent à

int temp = ++b; 
/* other threads can modify `b` but its value has been save in temp ... */ 
a.store(temp);