C++ => std :: atomics

Atomtypen

Jede Instantiierung und vollständige Spezialisierung der std::atomic Vorlage definiert einen atomaren Typ. Wenn ein Thread in ein atomares Objekt schreibt, während ein anderer Thread daraus liest, ist das Verhalten genau definiert (Informationen über Datenrennen finden Sie unter Speichermodell).

Darüber hinaus können Zugriffe auf atomare Objekte eine Inter-Thread-Synchronisation herstellen und nicht-atomare Speicherzugriffe std::memory_order wie in std::memory_order .

std :: atomic kann mit jedem TriviallyCopyable type T. std::atomic instanziiert werden TriviallyCopyable type T. std::atomic ist weder kopierbar noch beweglich.

Die Standardbibliothek bietet Spezialisierungen der Vorlage std :: atomic für die folgenden Typen:

Eine volle Spezialisierung für den Typ bool und seine typedef Name definiert , die als nicht-spezialisierten behandelt wird std::atomic<T> , außer dass es Standard - Layout hat, trivial Standardkonstruktors, trivial Destruktoren und unterstützt Aggregat Initialisierung Syntax:

Typedef Name	Volle Spezialisierung
`std::atomic_bool`	`std::atomic<bool>`

2) Vollständige Spezialisierungen und Typedefs für ganzzahlige Typen wie folgt:

Typedef Name	Volle Spezialisierung
`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>`

Einfaches Beispiel für die Verwendung von 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

Lizenziert unter CC BY-SA 3.0

Nicht angeschlossen an Stack Overflow

C++
std :: atomics

Suche…

Atomtypen