C++ c++；0x无原子操作的多线程内存可见性

使用atomics在线程之间同步数据（除了使用spinlock）的常见模式如下：

int data;
std::atomic<bool> ready;

void thread1()
{
   data = 123;
   ready.store(true, std::memory_order_release);
}
void thread2()
{
   while(!ready.load(std::memory_order_acquire));
   int theData = data;
   assert(theData == 123);
}

“就绪”标志用于1）确定数据何时确实就绪，2）确定关系之前发生的事件

<>但是如果我知道（不使用C++原子能），当我读数据时，数据会准备好，那么我能省略这种标志吗？< /P> 我可以用这个吗

int data = 0;
void thread1()
{
   sleep(1000);
   data = 123;
   std::atomic_thread_fence(some_order);
}
void thread2()
{
   sleep(2000);
   std::atomic_thread_fence(some_order);
   int theData = data;
   assert(theData == 123);
}

或

std:：原子atmData（0）；
void thread1（）
{
睡眠（1000）；
atmData.store（123，一些订单）；
}
无效线程2（）
{
睡眠（2000年）；
int theData=atmData.load（某些顺序）；
断言（数据=123）；
}

如果是这样的话，那么什么样的订单呢？ 我不确定这是否可能，因为即使使用

std:：memory\u order\u seq\u cst

排序操作仍然可以看到过时的值。另一方面，

std:：atomic_thread_fence（）

似乎需要原子操作才能工作（根据）

---

<>编辑：这是一个关于C++中内存同步工作的理论问题，而不是如何使用等待机制或知道何时访问数据是安全的。没有任何类型的“标准模式”用于同步线程，事实上，互斥体和条件变量的使用频率远远高于原子。我一直想给你我的答案（是的，当然，是的），但我不得不问。。。您认为您知道如何获得数据“就绪”的信心吗？除非您非常频繁地从多个线程写入/读取atmData，否则使用简单的互斥模式可能会更具可读性。还有，你为什么说“旋转等待”是标准的？如果你问C++标准是否提供了某种保证，它可以安全地调用<代码>消费<代码> >从另一种语言中获得代码< > in> <代码>，如果该语言确保足够的同步，那么C++标准当然不提供这样的保证，原因很简单，它根本没有考虑一个由不同语言编写的片段组装而成的程序。这样一个程序的行为是由实现定义的，因此您需要参考特定的实现。如果你问了别的问题，如果你明确地陈述这个问题，这将是有帮助的。如果你相信这个事件的顺序和C++的保证之后一样好，那么你就不需要在C++方面进行任何同步。如果您怀疑它比之后发生的更弱，那么您必须将

init

和

consume

调用视为未进行外部同步，并根据需要提供内部同步。检查另一种语言的记忆模型，以确定您希望在哪种假设下工作。你的困惑来自于试图两者兼顾。

int data = 0;
void thread1()
{
   sleep(1000);
   data = 123;
   std::atomic_thread_fence(some_order);
}
void thread2()
{
   sleep(2000);
   std::atomic_thread_fence(some_order);
   int theData = data;
   assert(theData == 123);
}

std::atomic<int> atmData(0);
void thread1()
{
   sleep(1000);
   atmData.store(123, some_order);
}
void thread2()
{
   sleep(2000);
   int theData = atmData.load(some_order);
   assert(theData == 123);
}