《C++并发编程实战》读书笔记（3）：内存模型和原子操作

第5章 C++内存模型和原子操作

5.1 内存模型基础

C++标准中对象定义为某一存储范围。每个变量都是对象，每个对象都占用至少一块内存区域，若变量属于内建基本类型则仅占用一块，相邻的位域属于同一块。

若两个线程访问同一内存区域并且没有强制服从一定的次序，当其中有非原子化访问以及写操作时，就会出现数据竞争，导致未定义行为。此场景下如果全都采用原子操作，虽然不能预防数据竞争，但可避免未定义行为。

所有线程在某对象上的全部写操作，称为该对象的改动序列。若采用了原子操作，编译器有责任保证有效的同步，禁止某些预测执行，以做到对任一对象，所有线程对其必须形成相同的改动序列。

5.2 C++中的原子操作及其类别

原子操作是不可分割的操作，或者完全做好或者完全没做。多数情况下需要通过原子类型实现原子操作。

原子类型的定义位于<atomic>，有些由原子指令直接实现，有些由锁来实现，无法取代互斥的同步方式从而获得性能提升。可以用成员函数is_lock_free来判断。对于原子类型上的每种操作，都可以提供额外参数，用于设定内存次序语义，具体见5.3节。

5.2.1 各类原子类型

std::atomic_flag是最简单的标准原子类型，保证无锁，表示一个布尔标志，唯一用途是充当构建单元。其对象必须由ATOMIC_FLAG_INIT初始化并置零，只支持clear、test_and_set。

class spinlock_mutex {
public:
    spinlock_mutex() : flag(ATOMIC_FLAG_INIT) {}
    void lock() {
        while (flag.test_and_set(std::memory_order_acquire));
    }
    void unlock() { 
        flag.clear(std::memory_order_release); 
    }
private:
    std::atomic_flag flag;
};

std::atomic<bool>是基于整数的最基本的原子类型，相比atomic_flag功能更齐全。它的赋值操作符直接按值而非按引用返回。

std::atomic<bool> b;
bool x = b.load(std::memory_order_acquire);
b.store(true);
x = b.exchange(false, std::memory_order_acq_rel);

它还支持“比较-交换”，包括compare_exchange_weak和compare_exchange_strong：给定期望值和原子变量比较，若相等则原子变量保存另一值并返回true，否则更新期望值为原子变量的值并返回false。它接收两个内存次序参数，对应成功与失败。

atomic<T*>支持上面atomic<bool>介绍的操作。还支持fetch_add/fetch_sub，对存储地址进行原子化的加减，返回旧值，藉此重载了+=、-=、++、--。

整数原子类型支持的操作比上述更加齐全。

5.2.2 非成员函数原子操作

原子操作不仅包括上述原子类型的成员函数，还包括很多非成员函数，第一个参数都是指向目标的指针。大部分是以成员函数加“atimic_”前缀来命名。

C++标准库还提供了针对shared_ptr的非成员函数，尽管它不属于原子类型。

std::shared_ptr<Widget> p;

void process_global_data(){
  std::shared_ptr<Widget> local = std::atomic_load(&p);
  process_data(local);
}

void update_global_data(){
  std::shared_ptr<Widget> local(new Widget);
  std::atomic_store(&p, local);
}

5.3 同步操作和强制次序

内存模型关系有先行与同步。同步关系指对某变量执行原子写和原子读，且两者都有适当的标记。先行关系在单线程中指源代码中操作语句的先后，多线程中先行关系可通过同步关系传递。

原子类型上的操作服从6种内存次序。宽松次序：memory_order_relaxed，获取-释放次序：memory_order_consume（建议不予采用）、memory_order_acquire、memory_order_release、memory_order_acq_rel，先后一致次序：memory_order_seq_cst。

先后一致次序是最严格的内存次序，同时也是默认参数。如果程序服从该次序，就简单地把一切事件视为按先后顺序发生，所有线程所见的一切操作都必须服从相同的次序。这样最符合直觉，比较容易理解。但其他次序中，不同线程看到的同一组操作的次序和效果可能呈现差异。

宽松次序仅要求同一线程内对相同变量的访问次序不能重排。可以将每个原子变量想象为一个记录员，记录着代表改动序列的一系列数据，记录本上每个线程都对应一个指向某一数据的用户标签，标签之间没有任何影响。当线程更新数据时记录员记下最新数据并把该线程的标签移到该最新数据下；线程询问记录员数据是多少时，（不论其他线程更新了多少数据、其他标签如何移动）记录员可能将该线程的标签往下移动任意位数据，也可能不移（代表CPU缓存是否同步），然后返回标签指向的数据。

例如一个线程先写x再写y，另一个线程先写y再写x，却可能出现图中的情况，这是因为x、y的读写在两个线程中，宽松次序对此不作规定，什么顺序都可能发生。

获取-释放次序比宽松次序严格一些，在成对的读写线程之间起同步作用。载入对应memory_order_acquire，存储对应memory_order_release，读-改-写对应memory_order_rel（根据具体语义也可以使用前面两个次序）。

可以考虑同一线程上的两个存储操作，下面代码中y读写的同步会强制x上的宽松操作服从一定次序。

std::atomic<bool> x, y;
std::atomic<int> z;

void write_x_then_y() {
    x.store(true, std::memory_order_relaxed);
    y.store(true, std::memory_order_release);
}

void read_y_then_x() {
    while (!y.load(std::memory_order_acquire))
        ;
    if (x.load(std::memory_order_relaxed)) ++z;
}

int main() {
    x = false;
    y = false;
    z = 0;
    std::thread a(write_x_then_y);
    std::thread b(read_y_then_x);
    a.join();
    b.join();
    assert(z.load() != 0);
}

针对同一个原子变量，如果先存储，再进行多个读-改-写，最后载入，其中所有存储的标记都是memory_order_release/memory_order_acq_rel或memory_order_seq_cst，而载入标记都是memory_order_acquire/memory_order_seq_cst，那么这些操作前后相扣为一个释放序列，最初的存储与最后的载入同步。

考虑下面的例子，第8行store是最初的存储，第14行fetch_sub是读-改-写，那么一个存储两个读-改-写形成释放序列，即store与第一个fetch_sub、store与第二个fetch_sub都同步，不存在数据竞争。

void populate_queue() {
    unsigned const number_of_items = 20;
    queue_data.clear();
    for (unsigned i = 0; i < number_of_items; ++i) {
        queue_data.push_back(i);
    }

    count.store(number_of_items, std::memory_order_release);
}

void consume_queue_items() {
    while (true) {
        int item_index;
        if ((item_index = count.fetch_sub(1, std::memory_order_acquire)) <= 0) {
            wait_for_more_items();
            continue;
        }
        process(queue_data[item_index - 1]);
    }
}

int main() {
    std::thread a(populate_queue);
    std::thread b(consume_queue_items);
    std::thread c(consume_queue_items);
    a.join();
    b.join();
    c.join();
}

最后，考虑用原子操作令非原子操作服从内存次序。下面的例子中两个内存屏障原子操作atomic_thread_fence之间同步，使得x先存储true再读取，最后的断言不会报错。前文我们介绍的thread/mutex/promise等等工具也都提供了同步关系，不再一一介绍。

bool x = false;
std::atomic<bool> y;
std::atomic<int> z;

void write_x_then_y() {
    x = true;
    std::atomic_thread_fence(std::memory_order_release);
    y.store(true, std::memory_order_relaxed);
}

void read_y_then_x() {
    while (!y.load(std::memory_order_relaxed))
        ;
    std::atomic_thread_fence(std::memory_order_acquire);
    if (x) ++z;
}

int main() {
    x = false;
    y = false;
    z = 0;
    std::thread a(write_x_then_y);
    std::thread b(read_y_then_x);
    a.join();
    b.join();
    assert(z.load() != 0);
}