C++
std :: atomics

types atomiques

Chaque instanciation et spécialisation complète du modèle std::atomic définit un type atomique. Si un thread écrit sur un objet atomique alors qu'un autre thread en lit un, le comportement est bien défini (voir le modèle de mémoire pour plus de détails sur les courses de données)

De plus, les accès aux objets atomiques peuvent établir une synchronisation inter-thread et ordonner des accès mémoire non atomiques comme spécifié par std::memory_order .

std :: atomic peut être instancié avec n'importe quel TriviallyCopyable type T. std::atomic n'est ni copiable ni mobile.

La bibliothèque standard fournit des spécialisations du modèle std :: atomic pour les types suivants:

1. Une spécialisation complète du type bool et de son nom typedef est définie, traitée comme un std::atomic<T> non spécialisé, sauf qu’elle a une disposition standard, un constructeur par défaut trivial, des destructeurs triviaux et prend en charge la syntaxe d’initialisation globale:

2) Spécialisations complètes et typedefs pour les types intégraux, comme suit:

Exemple simple d'utilisation de std :: atomic_int

#include <iostream>       // std::cout
#include <atomic>         // std::atomic, std::memory_order_relaxed
#include <thread>         // std::thread

std::atomic_int foo (0);

void set_foo(int x) {
  foo.store(x,std::memory_order_relaxed);     // set value atomically
}

void print_foo() {
  int x;
  do {
    x = foo.load(std::memory_order_relaxed);  // get value atomically
  } while (x==0);
  std::cout << "foo: " << x << '\n';
}

int main ()
{
  std::thread first (print_foo);
  std::thread second (set_foo,10);
  first.join();
  //second.join();
  return 0;
}
//output: foo: 10