一、简介

原子类型的对象包含特定type ()的值。
原子对象的主要特征是，从不同的线程访问这个包含的值不会导致数据竞争（即，这样做是明确定义的行为，访问正确排序）。通常，对于所有其他对象，导致同时访问同一对象的数据争用的可能性将操作限定为未定义行为。
【官方介绍】。此外，对象能够通过指定不同的内存顺序来同步对其线程中其他非原子对象的访问。

template <class T> struct atomic;

二、成员函数

2.1、构造函数

std::atomic::atomic。
（1）默认：使对象处于未初始化状态。 atomic() noexcept = default;
（2）初始化：使用val初始化对象。constexpr atomic (T val) noexcept;
（3）复制 [删除] ：无法复制/移动对象。 atomic (const atomic&) = delete;
示例：

std::atomic<bool> ready (false);

2.2、is_lock_free函数

bool is_lock_free() const volatile noexcept;
bool is_lock_free() const noexcept;

指示对象是否无锁。无锁对象不会导致其他线程在访问时被阻塞（可能使用该类型的某种事务内存）。
此函数返回的值与为同一类型的所有其他对象返回的值一致；调用此成员函数不会启动任何数据争用。
如果对象是无锁的返回true。

2.3、store函数

void store (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;
void store (T val, memory_order sync = memory_order_seq_cst) noexcept;

修改包含的值。将包含的值替换为val。该操作是原子操作。
参数是以下类型的可能值之一：

value	内存顺序	描述
memory_order_relaxed	宽松	副作用不同步
memory_order_consume	消费	同步对携带来自上一版本或顺序一致操作的依赖项的值的可见副作用。
memory_order_acquire	获得	同步上一版本或顺序一致操作的所有可见副作用。
memory_order_seq_cst	顺序一致	将所有可见的副作用与其他顺序一致的操作同步，遵循单个总订单。

示例：

std::atomic<int> foo (0);

foo.store(x,std::memory_order_relaxed);     // set value atomically

2.4、load函数

T load (memory_order sync = memory_order_seq_cst) const volatile noexcept;
T load (memory_order sync = memory_order_seq_cst) const noexcept;

读取包含的值，返回包含的值。该操作是原子操作。
参数是以下类型的可能值之一：

value	内存顺序	描述
memory_order_relaxed	宽松	副作用不同步
memory_order_consume	消费	同步对携带来自上一版本或顺序一致操作的依赖项的值的可见副作用。
memory_order_acquire	获得	同步上一版本或顺序一致操作的所有可见副作用。
memory_order_seq_cst	顺序一致	将所有可见的副作用与其他顺序一致的操作同步，遵循单个总订单。

示例：

std::atomic<int> foo (0);

int x;
do {
    x = foo.load(std::memory_order_relaxed);  // get value atomically
} while (x==0);

2.5、exchange函数

T exchange (T val, memory_order sync = memory_order_seq_cst) volatile noexcept;
T exchange (T val, memory_order sync = memory_order_seq_cst) noexcept;

访问和修改包含的值，将包含的值替换并返回它前面的值。
整个操作是原子的（原子读-修改-写操作）：从读取（要返回）值的那一刻到此函数修改值的那一刻，该值不受其他线程的影响。
示例：

#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread
#include <vector>         // std::vector

std::atomic<bool> ready (false);
std::atomic<bool> winner (false);

void count1m (int id) {
  while (!ready) {}                  // wait for the ready signal
  for (int i=0; i<1000000; ++i) {}   // go!, count to 1 million
  if (!winner.exchange(true)) { std::cout << "thread #" << id << " won!\n"; }
};

int main ()
{
  std::vector<std::thread> threads;
  std::cout << "spawning 10 threads that count to 1 million...\n";
  for (int i=1; i<=10; ++i) threads.push_back(std::thread(count1m,i));
  ready = true;
  for (auto& th : threads) th.join();

  return 0;
}

2.6、compare_exchange_weak函数

bool compare_exchange_weak (T& expected, T val,memory_order sync = memory_order_seq_cst) volatile noexcept;
bool compare_exchange_weak (T& expected, T val,memory_order sync = memory_order_seq_cst) noexcept;
bool compare_exchange_weak (T& expected, T val,memory_order success, memory_order failure) volatile noexcept;
bool compare_exchange_weak (T& expected, T val,memory_order success, memory_order failure) noexcept;

比较和交换包含的价值（weak）。将对象的包含值的内容与：

如果为 true，则用（like）替换包含的值。
如果为 false，则替换为包含的值。

该函数始终访问包含的值以读取它，并且 - 如果比较为 true- 它也会替换它。但是整个操作是原子的：在读取值的那一刻和替换值的那一刻之间，其他线程不能修改该值。

请注意，此函数直接将所包含值的物理内容与 ;这可能会导致对相等使用的值进行比较失败（如果基础类型具有填充位、陷阱值或相同值的替代表示形式），尽管此比较应在保留的循环中快速收敛。

与不同的是，这个weak版本允许通过返回来虚假地失败，即使预期确实等于所包含的对象。对于某些循环算法，这可能是可接受的行为，并且可能会在某些平台上显著提高性能。在这些虚假故障中，函数返回而不修改。

#include <iostream>       // std::cout
#include <atomic>         // std::atomic
#include <thread>         // std::thread
#include <vector>         // std::vector

// a simple global linked list:
struct Node { int value; Node* next; };
std::atomic<Node*> list_head (nullptr);

void append (int val) {     // append an element to the list
  Node* oldHead = list_head;
  Node* newNode = new Node {val,oldHead};

  // what follows is equivalent to: list_head = newNode, but in a thread-safe way:
  while (!list_head.compare_exchange_weak(oldHead,newNode))
    newNode->next = oldHead;
}

int main ()
{
  // spawn 10 threads to fill the linked list:
  std::vector<std::thread> threads;
  for (int i=0; i<10; ++i) threads.push_back(std::thread(append,i));
  for (auto& th : threads) th.join();

  // print contents:
  for (Node* it = list_head; it!=nullptr; it=it->next)
    std::cout << ' ' << it->value;
  std::cout << '\n';

  // cleanup:
  Node* it; while (it=list_head) {list_head=it->next; delete it;}

  return 0;
}

2.7、compare_exchange_strong函数

比较和交换包含的值（strong）。将包含的值的内容与：

如果为 true，则用（like）替换包含的值。
如果为 false，则替换为包含的值。

该函数始终访问包含的值以读取它，并且如果比较为 true它也会替换它。但是整个操作是原子的：在读取值的那一刻和替换值的那一刻之间，其他线程不能修改该值。

请注意，此函数直接将所包含值的物理内容与 ;这可能会导致对相等使用的值进行比较失败（如果基础类型具有填充位、陷阱值或相同值的替代表示形式），尽管此比较应快速收敛到保留的循环中，例如通常与一起使用的循环。

不同的是，这个强版本需要总是在预期确实等于所包含对象时返回，不允许虚假的失败。但是，在某些计算机上，对于在循环中检查此情况的某些算法，可能会显著提高性能。

2.8、专业化支持的操作

操作	含义
fetch_add	添加到包含的值并返回它在操作之前具有的值
fetch_sub	从包含的值中减去，并返回它在操作之前的值。
fetch_and	读取包含的值，并将其替换为在读取值和之间执行按位 AND 运算的结果。
fetch_or	读取包含的值，并将其替换为在读取值和之间执行按位 OR 运算的结果。
fetch_xor	读取包含的值，并将其替换为在读取值和之间执行按位 XOR 运算的结果。

三、使用示例

// atomic::load/store example
#include <iostream> // std::cout
#include <atomic> // std::atomic, std::memory_order_relaxed
#include <thread> // std::thread
//std::atomic<int> count = 0;//错误初始化
std::atomic<int> count(0); // 准确初始化
void set_count(int x)
{
	std::cout << "set_count:" << x << std::endl;
	count.store(x, std::memory_order_relaxed); // set value atomically
}
void print_count()
{
	int x;
	do {
		x = count.load(std::memory_order_relaxed); // get value atomically
	} while (x==0);
	std::cout << "count: " << x << '\n';
}
int main ()
{
	std::thread t1 (print_count);
	std::thread t2 (set_count, 10);
	t1.join();
	t2.join();
	std::cout << "main finish\n";
	return 0;
}