问题描述
考虑下面的代码：
// Class member initialization:
std::atomic<bool> ready_ = false;
...
// Core A:
while (!ready_.load(std::memory_order_acquire)) {
// On x86,you would probably put a `pause` instruction here.
}
// Core A Now accesses memory written by Core B.
...
// Core B:
// Core B writes memory.
ready_.store(true,std::memory_order_release);
假设核心 A 和核心 B 是两个不同的物理核心（即，它们不是共同位于同一物理核心上的两个超线程）。上面的 Core A 代码的性能是否比下面的代码更差或性能相同？请注意，Core A 只是在做负载；这不是涉及写入的经典比较交换示例。我对几种架构的答案很感兴趣。
// Core A:
while (!ready_.load(std::memory_order_relaxed)) {
// On x86,you would probably put a `pause` instruction here.
}
std::atomic_thread_fence(std::memory_order_acquire);
// Core A Now accesses memory written by Core B.
这个reference page上的邮箱代码暗示了底部代码具有更好的性能，因为底部代码避免了“不必要的同步”。但是，邮箱代码会迭代许多原子，因此获取一致性的同步开销是一个问题，因为您可以使用宽松的一致性来避免对不属于您的邮箱的排序约束。我不清楚在单个获取负载上旋转对性能有何影响。
解决方法
至少在某些假设的架构上，第一种代码的效率可能低于第二种代码，这有两种方式。在 x86 上，我猜它们会编译为相同的代码。
第一个问题是原子负载可能会影响其他处理器的性能。在 alpha 上，这通常是研究内存一致性的一个很好的“异常值”案例，你会一遍又一遍地发出内存屏障指令，这可能会锁定内存总线（在非 NUMA 机器上），或者做一些事情其他两个 CPU 强制写入存储的原子性。
第二个问题是屏障会影响所有先前的加载，而不仅仅是 ready_ 的加载。因此，也许在 NUMA 机器上，ready_ 实际上在缓存中命中，因为没有争用并且您的 CPU 已经以独占模式缓存它，但是之前的一些负载正在等待内存系统。现在您必须停止 CPU 以等待先前的加载，而不是继续执行与停止加载不冲突的指令。举个例子：
int a = x.load(memory_order_relaxed);
while (!ready_.load(std::memory_order_relaxed))
;
std::atomic_thread_fence(std::memory_order_acquire);
int b = y;
在这种情况下，y 的加载可能会暂停等待 x，而如果 ready_ 的加载已经使用获取语义完成，那么 {{1} 的加载} 可以并行继续，直到需要该值。
出于第二个原因，您实际上可能希望以不同的方式构建自旋锁。以下是 Erik Rigtorp 如何建议在 x86 上实现自旋锁，您可以轻松地适应您的用例：
x