bool expected = false;
extern atomic<bool> b;
while(!b.compare_exchange_weak(expected,true) && !expected);

2.3、操作std::atomic<T*>

除了std::atomic<bool>所支持的操作外，std::atomic<T*>还支持算术形式的指针运算。fetch_add()和fetch_sub()分别就对象中存储的地址进行原子化加减，然后返回原来的地址。另外，该原子类型还具有包装成重载运算符的+=和-=，以及++和--的前后缀版本，这些运算符作用在原子类型之上，效果与作用在内建类型上一样。

class Foo {};
Foo some_array[5];
std::atomic<Foo*> p(some_array);
Foo* x = p.fetch_add(2);
assert(x == some_array);
assert(p.load() == &some_array[2]);
x = (p -= 1);
assert(x == &some_array[1]);
assert(p.load() == &some_array[1]);

2.4、操作标准整数原子类型

在std::atomic<int>这样的整数原子类型上，除了std::atomic<T*>所支持的操作外，还支持fetch_and()、fetch_or()、fetch_xor()操作，也支持对应的&=、|=、^=复合赋值形式。

2.5、泛化的std::atomic<>类模板

除了前文的标准原子类型，使用者还能利用泛化模板，依据自定义类型创建其它原子类型。然而，对于某个自定义的类型UDT，必须要满足一定条件才能具现化出std::atomic<UDT>：

• 必须具有平实拷贝赋值运算符（平直、简单的原始内存赋值及其等效操作）。若自定义类型具有基类或非静态数据成员，则它们同样必须具备平实拷贝赋值运算符。
• 不得含有虚函数，也不可以从虚基类派生得出。
• 必须由编译器代其隐式生成拷贝赋值运算符。

由于以上限制，赋值操作不涉及任何用户编写的代码，因此编译器可以借用memcpy()或采取与之等效的行为完成它。另外值得注意的是，“比较-交换”操作采取的是逐位比较运算，效果等同于直接使用memcmp()函数。

3、内存顺序

编译器优化代码时可能会进行指令重排，而且CPU执行指令时也可能会乱序执行，所以代码的执行顺序不一定和书写顺序一致。例如下面的代码可能会按照如表所示的顺序执行，从而引发断言错误。可以看出，指令重排在单线程环境下不会造成逻辑错误，但在多线程环境下可能会造成逻辑错误。

int a = 0;
bool flag = false;
void func1()
{
    a = 1;
    flag = true;
}
void func2()
{
    if (flag)
    {
        assert(a == 1);
    }
}
std::thread t1(func1);
std::thread t2(func2);
t1.join();
t2.join();

内存顺序的作用，本质上是要限制单个线程中的指令顺序，从而解决多线程环境下可能出现的问题。原子类型上的操作服从6种内存顺序，在不同的CPU架构上，这几种内存模型也许会有不同的运行开销。

enum memory_order {
    memory_order_relaxed,
    memory_order_consume,
    memory_order_acquire,
    memory_order_release,
    memory_order_acq_rel,
    memory_order_seq_cst
};

• memory_order_seq_cst

  这是所有原子操作的内存顺序参数的默认值，语义上要求底层提供顺序一致性模型，不存在任何重排，可以解决一切问题，但是效率最低。

• memory_order_release / memory_order_acquire / memory_order_consume

  release操作可以阻止这个调用之前的读写操作被重排到后面去；acquire操作则可以保证这个调用之后的读写操作不会重排到前面去；consume操作比acquire操作宽松一些，它只保证这个调用之后的对原子变量有依赖的操作不会被重排到前面去。release与acquire/consume操作需要在同一个原子对象上配对使用，例如：

  std::atomic<int> a;
  std::atomic<bool> flag;
  void func1()
  {
      a = 1;
      flag.store(true, memory_order_release);
  }
  void func2()
  {
      if (flag.load(memory_order_acquire))
      {
          assert(a == 1);
      }
  }
  

• memory_order_acq_rel

  兼具acquire和release的特性。

• memory_order_relaxed

  只保证原子类型的成员函数操作本身是不可分割的，但是对于顺序性不做任何保证。

三类操作支持的内存顺序如下表所示：