获取-释放对乱序执行

Question

我正在考虑原子变量是否可以加载获取-释放对中的旧值。 假设我们有原子变量 x，并且我们使用释放语义存储该变量，然后使用获取语义加载它，理论上是否可以读取旧值？

std::atomic<int> x = 0;

void thread_1()
{
   x.store(1, std::memory_order_release);
}
void thread_2()
{
   assert(x.load(std::memory_order_acquire) != 0);
}

如果函数线程 1 在线程 2 加载 x 时完成（因此存储了新值），线程 2 是否可以从 x 加载旧值？换句话说，如果在加载之前完成对 x 的实际存储，是否有可能触发断言？

据我从互联网文章中了解到这是可能的，但我不明白为什么。由store to x生成的内存栅栏保证清空存储缓冲区，而从x加载中获取内存栅栏保证使缓存行无效，因此它必须读取最新值。

添加

这是否意味着获取-释放本身没有任何强制顺序？只有在发布之前完成的所有操作都会在发布之前发生，而在获取之后完成的所有操作都会在发布之后发生，因此获取-释放对强制对其他操作进行排序（为什么？）。我做对了吗？ 则断言保证不会再次触发

std::atomic<int> x = 0;
std::atomic<int> y = 0;

void thread_1()
{
   y.store(1, std::memory_order_relaxed);
   x.store(1, std::memory_order_release);
}
void thread_2()
{
   x.load(std::memory_order_acquire);
   assert(y.load(std::memory_order_relaxed) != 0);
}

这是否意味着在下面的代码中，如果线程 1 已经完成存储， 。如果我们用 while (x.load() == 0) 替换 x.load ，这将 100% 工作，但我不知道是什么导致它工作。

如果我用下面的代码替换代码会怎么样，

std::atomic<int> x = 0;

void thread_1()
{
   x.exchange(1, std::memory_order_acq_rel);
}
void thread_2()
{
   assert(x.exchange(0, std::memory_order_acq_rel) != 0);
}

它会改变什么吗？

谢谢。

Answer 1

您可能会将具有释放/获取内存顺序的存储/加载函数视为以下伪代码：

template<class T>
struct weak_atomic
{
   void store(T newValue)
   {
      ReleaseBarrier();
      m_value = newValue;
   }

   T load()
   {
      T value = m_value;
      AcquireBarrier();
      return value;      
   }

   volatile T m_value;
}

您说

存储到 x 生成的内存栅栏
保证清空存储缓冲区

据我所知，释放内存屏障将导致 CPU 刷新其存储缓冲区，但它将在将新值应用于 x 之前完成。因此，似乎可以通过另一个 CPU 从 x 读取旧值。

无论如何，弱原子是一个非常复杂的领域。在进行无锁编程之前，请确保您了解内存屏障。

添加

看来您仍然对内存障碍感到困惑。这是其用法的一个非常常见的示例。

volatile int  x;
volatile bool ok;

void thread_1()
{
   x = 100;
   ok = true;
}

void thread_2()
{
   if (ok)
   {
      assert(x == 100);
   }
}

由于无序执行，您可能会得到以下序列：

thread 1 sets ok to true
thread 2 checks ok is true and reads some garbage from x
thread 1 sets x to 100 but it is too late

另一个可能的序列：

thread 2 reads some garbage from x
thread 2 checks for ok value

我们可以通过释放和获取内存屏障来修复该问题。

volatile int  x;
volatile bool ok;

void thread_1()
{
   x = 100;
   ReleaseBarrier();
   ok = true;
}

void thread_2()
{
   if (ok)
   {
      AcquireBarrier();
      assert(x == 100);
   }
}

ReleaseBarrier() 保证内存写入不能跳过屏障。
这意味着仅当 x 已包含有效值时，ok 才会设置为 true。

AcquireBarrier() 保证内存读取不能跳过屏障。
这意味着只有在检查 ok 状态后才会读取 x 的值。

这就是释放/获取对的用途。我们可以用我的 weak_atomic 重写这个示例。

volatile int  x;
weak_atomic<bool> ok;

void thread_1()
{
   x = 100;
   ok.store(true);
}

void thread_2()
{
   if (ok.load())
   {
      assert(x == 100);
   }
}