C++
std :: Atomics

tipi atomici

Ogni istanza e specializzazione completa del modello std::atomic definisce un tipo atomico. Se un thread scrive su un oggetto atomico mentre un altro thread legge da esso, il comportamento è ben definito (vedi il modello di memoria per i dettagli sulle gare di dati)

Inoltre, gli accessi agli oggetti atomici possono stabilire la sincronizzazione tra thread e ordinare accessi di memoria non atomici come specificato da std::memory_order .

std :: atomic può essere istanziato con qualsiasi TriviallyCopyable type T. std::atomic non è né copiabile né mobile.

La libreria standard fornisce le specializzazioni del modello std :: atomic per i seguenti tipi:

1. Viene definita una specializzazione completa per il tipo bool e il suo nome typedef che viene trattato come std::atomic<T> non specializzato, tranne che ha un layout standard, un costruttore banale di default, distruttori banali e supporta la sintassi di inizializzazione aggregata:

2) Specializzazioni complete e typedef per tipi interi, come segue:

Semplice esempio di utilizzo di 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