C++原子变量atomic详解

• 一、简介
• 二、成员函数
• • 2.1、构造函数
  • 2.2、is_lock_free函数
  • 2.3、store函数
  • 2.4、load函数
  • 2.5、exchange函数
  • 2.6、compare_exchange_weak函数
  • 2.7、compare_exchange_strong函数
  • 2.8、专业化支持的操作
• 三、使用示例
• 总结

一、简介

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

template  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 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。该操作是原子操作。
参数是以下类型的可能值之一：

示例：

std::atomic 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;

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

示例：

std::atomic 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        // std::cout
#include          // std::atomic
#include          // std::thread
#include          // std::vectorstd::atomic ready (false);
std::atomic winner (false);void count1m (int id) {while (!ready) {}                  // wait for the ready signalfor (int i=0; i<1000000; ++i) {}   // go!, count to 1 millionif (!winner.exchange(true)) { std::cout << "thread #" << id << " won!\n"; }
};int main ()
{std::vector 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        // std::cout
#include          // std::atomic
#include          // std::thread
#include          // std::vector// a simple global linked list:
struct Node { int value; Node* next; };
std::atomic list_head (nullptr);void append (int val) {     // append an element to the listNode* 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 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、专业化支持的操作

三、使用示例

// atomic::load/store example
#include  // std::cout
#include  // std::atomic, std::memory_order_relaxed
#include  // std::thread
//std::atomic count = 0;//错误初始化
std::atomic 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;
}

总结

原子操作在多线程中可以保证线程安全，而且效率会比互斥量好些。