synchronizes-with关系 synchronizes-with 关系是你只能在原子类型上的操作之间得到的东西。如果一个数据结构包含原子类型，并且在该数据结构上的操作会内部执行适当的原子操作，该数据结构上的操作（如锁定互斥元）可能会提供这种关系，但是从根本上说synchronizes-with关系只出自原子类型上的操作。
基本思想： 在一个变量x上的一个被适当标记的原子写操作w， 与在x上的一个被适当标记的，通过写入(W)，或是由与执行最初的写操作W相同的线程在x上的后续原子写操作，或是由任意线程在x上一系列的原子的读-修改-写操作（fetch_add()或compare_exchange_weak()）来读取所存储的值的原子读操作同步，其中随后通过第一个线程读取的值是通过W写入的值。synchronizes-with关系。
happens-before 关系 happens-before(发生于之前)关系是程序中操作顺序的基本构件，它指定了哪些操作看到其他操作的结果。对于单个线程，它是直观的，如果一个操作排在另一个操作之前，那么该操作就发生于另一个操作之前。这就意味着，如果一个操作（A）发生于另一个操作(B)之前的语句里，那么A就发生于B之前。
有时候，单条语句中的操作是有顺序的，例如使用内置的逗号操作符或者使用一个表达式的结果作为另一个表达式的参数。sequenced-before（因此也没有happens-before）.当然，一条语句的所有操作在下一句的所有操作之前发生。
原子操作的内存顺序 有六种内存顺序选项可以应用到原子类型上的操作：
memory_order_relaxed
memory_order_consume
memory_order_acquire
memory_order_release
memory_order_acq_rel
memory_order_seq_cst
除非你为某个特定的操作做出指定，原子类型上的所有操作的内存顺序选项都是memory_order_seq_cst, 这是最严格的可用选项。
尽管有六种选项，它们其实代表了三种模型：
顺序一致(sequentially consistent)顺序(memory_order_seq_cst)
获得-释放(acquire_release)顺序(memory_order_consume、memory_order_acquire、memory_order_release和memory_order_acq_rel)
松散(relaxed)顺序(memory_order_relaxed)
如果这些系统拥有很多处理器，这些额外的同步指令可能占据显著的时间量，从而降低该系统的整体性能。
不同的内存顺序模型的可用性，允许高手们利用更细粒度的顺序关系来提升性能，在不太关键的情况下，当允许使用默认的顺序一致顺序时，它们是有优势的。
1. 顺序一致顺序 默认的顺序被命名为顺序一致(sequentially consistent), 因为这意味着程序的行为与一个简单的顺序的世界观时一致的。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 #include <atomic> #include <thread> #include <cassert> std::atomic<bool > x, y; std::atomic<int > z; void write_x () x.store (true , std::memory_order_seq_cst); } void write_y () y.store (true , std::memory_order_seq_cst); } void read_x_then_y () while (!x.load (std::memory_order_seq_cst)); if (y.load (std::memory_order_seq_cst)) { ++z; } } void read_y_then_x () while (!y.load (std::memory_order_seq_cst)); if (x.load (std::memory_order_seq_cst)) { ++z; } } int main () x = false ; y = false ; z = 0 ; std::thread d (read_y_then_x) ; std::thread c (read_x_then_y) ; std::thread a (write_x) ; std::thread b (write_y) ; a.join (); b.join (); c.join (); d.join (); assert (z.load () != 0 ); }
顺序一致时最直观和直觉的排序，但也是最昂贵的内存顺序，因为它要求所有线程之间的全局同步。在多处理器系统中，这可能需要处理器之间相当密集和耗时的通信。
2. 非顺序一致的内存顺序 时间不再有单一的全局顺序，这意味着不同的线程可能看到相同的操作的不同方面。你不仅得考虑事情真正的并行发生，而且线程不必和事件的顺序一致。
3. 松散顺序 以松散顺序执行的原子类型上的操作不参与synchronzes-with关系。单线程中的同一个变量的操作仍然服从happens-before关系，但对于其他线程的顺序几乎没有任何要求。唯一的要求是，从同一个线程对单个原子变量的访问不能被重排，一旦给定的线程看到了原子变量的特定值，该线程之后的读取就不能获取该变量更早的值。memory_order_relaxed的线程之间唯一共享的东西。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 #include <atomic> #include <thread> #include <cassert> 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_relaxed); } void read_y_then_x () while (!y.load (std::memory_order_relaxed)); if (x.load (std::memory_order_relaxed)) { ++z; } } int main () x = false ; y = false ; z = 0 ; std::thread b (read_y_then_x) ; std::thread a (write_x_then_y) ; a.join (); b.join (); assert (z.load () != 0 ); }
这里的assert可以触发，因为x的载入能够读到false，即使y的载入读到了true，并且x的存储发生于y存储之前。x和y是不同的变量，所以关于每个操作所产生的值的可见性没有顺序保证。
不同变量的松散操作可以被自由地重排前提是它们服从所有约束下的happens-before关系（例如在同一个线程中）。synchronizes-with关系。即便在存储操作中存在happens-before关系，但任一存储和任一载入之间却不存在，所以载入可以在顺序之外看到存储。
4. 获取-释放顺序 获取-释放顺序是松散顺序的进步，操作仍然没有总的顺序，但的确引入了一些同步。在这用顺序模型下，原子载入时获取操作(memory_order_acquire)，原子存储时释放操作(memory_order_release), 原子的读-修改-写操作是获取、释放或两者兼备(memory_order_acq_rel)。同步在进行释放的线程和进行获取的线程之间是对偶的。释放操作与读取写入值的获取操作同步。这意味着，不同的线程仍然可以看到不同的排序，但这些顺序是受到限制的
5. 使用获取-释放顺序和MEMORY_ORDER_CONSUME的数据依赖 有两个处理数据历来的新的关系：依赖顺序在其之前(dependency-ordered-before)和带有对其的以来(carries-a-dependency-to)。sequenced-before相似，carries-a-dependency-to严格适用于的单个线程之内，是操作间数据以来的基本模型。如果操作A的结果被用于操作B的操作数，那么A带有对B的依赖。如果操作A的结果是类似int的标量类型的值，那么如果A的结果存储一个变量中，并且该变量随后被用作操作B的操作数，此关系也是适用的。这种操作具有传递性，所以如果A带有对B的以来且B带有对C的依赖，那么A带有对C的依赖。
另一方面，depency-order-before的关系可以适用于线程之间。它是通过使用标记了memory_order_consume的原子载入操作引入的。memory_order_acquire的一种特例，它限制了对直接依赖的数据同步。标记为memroy_order_release、memory_order_acq_rel或memory_order_seq_cst的存储操作A的依赖顺序在标记为memory_order_acquire，那么这与synchronizes-with关系所得到的是相反的。如果操作B带有对操作C的某种依赖，那么A也是依赖顺序在C之前。
如果这对线程间happens-before关系没有影响，那么在同步目的上就无法为你带来任何好处，但它的却实现了：如果A依赖顺序在B之前，则A也是线程间发生于B之前。
这种内存顺序的一个重要用途，是在原子操作载入指向某数据的指针的场合。通过在载入上使用memory_order_consume以及在之前的存储上使用memory_order_release, 你可以确保所指向的数据得到正确的同步，无需在其他非依赖的数据上强加任何同步需求。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 #include <atomic> #include <thread> #include <cassert> #include <string> struct X { int i; std::string s; }; std::atomic<X*> p; std::atomic<int > a; void create_x () X* x = new X; x->i = 42 ; x->s = "hello" ; a.store (99 , std::memory_order_relaxed); p.store (x, std::memory_order_release); } void use_x () X* x; while (!(x = p.load (std::memory_order_consume))) { std::this_thread::sleep_for (std::chrono::microseconds (1 )); } assert (x->i == 42 ); assert (x->s == "hello" ); assert (a.load (std::memory_order_relaxed) == 99 ); } int main () std::thread t2 (use_x) ; std::thread t1 (create_x) ; t1. join (); t2. join (); }