Atomique pointeurs en c++ et les objets de passage entre les threads

La réponse est oui, et peut-être pas

Le modèle de mémoire principes:

C++11 atomics utilisation par défaut la std::memory_order_seq_cst de la mémoire de la commande, ce qui signifie que les opérations sont séquentiellement cohérente.

Sur le plan sémantique, c'est que la commande de l'ensemble des opérations est comme si toutes ces opérations ont été effectuées de manière séquentielle :

• C++ standard de l'article 29.3/3 explique comment cela fonctionne pour atomics: "Il y aura un seul total de la commande S sur tous les memory_order_seq_cst opérations, en cohérence avec la “passe avant” de l'ordre et de la modification des commandes pour tous les endroits touchés, de sorte que chaque memory_order_seq_cst
  opération qui se charge d'une valeur constate soit la dernière modification selon cet ordre S, ou le résultat d'une opération qui n'est pas memory_order_seq_cst."

• La section 1.10/5 explique comment cela impacte aussi des non-atomics: "La bibliothèque définit un certain nombre d'opérations atomiques (...) qui sont spécialement identifiés comme les opérations de synchronisation. Ces opérations jouent un rôle dans l'élaboration des affectations en un seul fil visible à l'autre."

La réponse à votre question est oui !

Risque de non-atomiques

Vous ne devez cependant être conscient que, en réalité, la cohérence de la garantie est plus limité pour les non-valeurs atomiques.

Supposons une première exécution du scénario:

(thread 1) A.foo = 10; 
(thread 1) A.foo = 4;     //stores an int
(thread 1) ptr.store(&A); //ptr is set AND synchronisation 
(thread 2) int i = *ptr;  //ptr value is safely accessed (still &A) AND synchronisation

Ici, i est 4. Parce que ptr est atomique, le fil (2) en toute sécurité obtient la valeur &A lorsqu'il lit le pointeur. La mémoire de la commande s'assure que tous les travaux effectués AVANT ptr sont vus par les autres threads ("passe avant" contrainte).

Mais supposons qu'une seconde d'exécution du scénario:

(thread 1) A.foo = 4;     //stores an int
(thread 1) ptr.store(&A); //ptr is set AND synchronisation 
(thread 1) A.foo = 8;     //stores int but NO SYNCHRONISATION !! 
(thread 2) int i = *ptr;  //ptr value is safely accessed (still &A) AND synchronisation

Ici, le résultat est indéfini. Il pourrait être de 4 à cause de la mémoire de commande de la garantie que ce qui se passe avant la ptr assignement est vu par les autres threads. Mais rien n'empêche les affectations effectuées par la suite d'être vu ainsi. Ainsi, il pourrait être 8.

Si vous avez eu *ptr = 8; au lieu de A.foo=8; ensuite, vous avez la certitude de nouveau: i serait 8.

Vous pouvez le vérifier expérimentalement avec ceci par exemple:

void f1() {  //to be launched in a thread
    secret = 50; 
    ptr = &secret; 
    secret = 777; 
    this_thread::yield();
}
void f2() { //to be launched in a second thread
    this_thread::sleep_for(chrono::seconds(2));
    int i = *ptr; 
    cout << "Value is " << i << endl;
}

Conclusions

Pour conclure, la réponse à votre question est oui, mais seulement si aucun autre changement de la non atomique données qui se passe après la synchronisation. Le principal risque est que seulement ptr est atomique. Mais cela ne s'applique pas aux valeurs souligné.

À noter que, en particulier des pointeurs apporter davantage de synchronisation de risque lorsque vous réaffectez le atomique pointeur vers un non atomique pointeur.

Exemple:

//Thread (1): 
std:atomic<Object*> ptr;
A.foo = 4;  //foo is an int;
ptr.store(*A);

//Thread (2): 
Object *x; 
x=ptr;      //ptr is atomic but x not !  
terrible_function(ptr);   //ptr is atomic, but the pointer argument for the function is not ! 

OriginalL'auteur Christophe