C++ => std :: atómica

tipos atómicos

Cada creación de instancias y la especialización completa de la plantilla std::atomic define un tipo atómico. Si un hilo se escribe en un objeto atómico mientras otro hilo lo lee, el comportamiento está bien definido (consulte el modelo de memoria para obtener detalles sobre las carreras de datos)

Además, los accesos a objetos atómicos pueden establecer la sincronización entre subprocesos y ordenar accesos de memoria no atómica según lo especificado por std::memory_order .

std :: atomic se puede crear una instancia con cualquier TriviallyCopyable type T. std::atomic no se puede copiar ni mover.

La biblioteca estándar proporciona especializaciones de la plantilla std :: atomic para los siguientes tipos:

Se define una especialización completa para el tipo bool y su nombre typedef que se trata como un std::atomic<T> no especializado, excepto que tiene un diseño estándar, un constructor predeterminado trivial, un destructor trivial y soporta la sintaxis de inicialización agregada:

Nombre de typedef	Especialización completa
`std::atomic_bool`	`std::atomic<bool>`

2) Especializaciones completas y typedefs para tipos integrales, como sigue:

Nombre de typedef	Especialización completa
`std::atomic_char`	`std::atomic<char>`
`std::atomic_char`	`std::atomic<char>`
`std::atomic_schar`	`std::atomic<signed char>`
`std::atomic_uchar`	`std::atomic<unsigned char>`
`std::atomic_short`	`std::atomic<short>`
`std::atomic_ushort`	`std::atomic<unsigned short>`
`std::atomic_int`	`std::atomic<int>`
`std::atomic_uint`	`std::atomic<unsigned int>`
`std::atomic_long`	`std::atomic<long>`
`std::atomic_ulong`	`std::atomic<unsigned long>`
`std::atomic_llong`	`std::atomic<long long>`
`std::atomic_ullong`	`std::atomic<unsigned long long>`
`std::atomic_char16_t`	`std::atomic<char16_t>`
`std::atomic_char32_t`	`std::atomic<char32_t>`
`std::atomic_wchar_t`	`std::atomic<wchar_t>`
`std::atomic_int8_t`	`std::atomic<std::int8_t>`
`std::atomic_uint8_t`	`std::atomic<std::uint8_t>`
`std::atomic_int16_t`	`std::atomic<std::int16_t>`
`std::atomic_uint16_t`	`std::atomic<std::uint16_t>`
`std::atomic_int32_t`	`std::atomic<std::int32_t>`
`std::atomic_uint32_t`	`std::atomic<std::uint32_t>`
`std::atomic_int64_t`	`std::atomic<std::int64_t>`
`std::atomic_uint64_t`	`std::atomic<std::uint64_t>`
`std::atomic_int_least8_t`	`std::atomic<std::int_least8_t>`
`std::atomic_uint_least8_t`	`std::atomic<std::uint_least8_t>`
`std::atomic_int_least16_t`	`std::atomic<std::int_least16_t>`
`std::atomic_uint_least16_t`	`std::atomic<std::uint_least16_t>`
`std::atomic_int_least32_t`	`std::atomic<std::int_least32_t>`
`std::atomic_uint_least32_t`	`std::atomic<std::uint_least32_t>`
`std::atomic_int_least64_t`	`std::atomic<std::int_least64_t>`
`std::atomic_uint_least64_t`	`std::atomic<std::uint_least64_t>`
`std::atomic_int_fast8_t`	`std::atomic<std::int_fast8_t>`
`std::atomic_uint_fast8_t`	`std::atomic<std::uint_fast8_t>`
`std::atomic_int_fast16_t`	`std::atomic<std::int_fast16_t>`
`std::atomic_uint_fast16_t`	`std::atomic<std::uint_fast16_t>`
`std::atomic_int_fast32_t`	`std::atomic<std::int_fast32_t>`
`std::atomic_uint_fast32_t`	`std::atomic<std::uint_fast32_t>`
`std::atomic_int_fast64_t`	`std::atomic<std::int_fast64_t>`
`std::atomic_uint_fast64_t`	`std::atomic<std::uint_fast64_t>`
`std::atomic_intptr_t`	`std::atomic<std::intptr_t>`
`std::atomic_uintptr_t`	`std::atomic<std::uintptr_t>`
`std::atomic_size_t`	`std::atomic<std::size_t>`
`std::atomic_ptrdiff_t`	`std::atomic<std::ptrdiff_t>`
`std::atomic_intmax_t`	`std::atomic<std::intmax_t>`
`std::atomic_uintmax_t`	`std::atomic<std::uintmax_t>`

Ejemplo simple de usar 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

Modified text is an extract of the original Stack Overflow Documentation

Licenciado bajo CC BY-SA 3.0

No afiliado a Stack Overflow

C++
std :: atómica

Buscar..

tipos atómicos