互斥锁能否确保对象的线程可见性而不显式保护它们？

Question

考虑到以下代码，线程是否有可能看到对象的状态不同，尽管它们都通过相同的指针引用？

using namespace std;

class ProducerAndConsumer{

  class DummyObject {
  public:
    DummyObject() {
      sprintf(a, "%d", rand());
    }
  private:
    char a[1000];
  };

  mutex queue_mutex_;
  queue<DummyObject *> queue_;
  thread *t1, *t2;

  void Produce() {
    while (true) {
      Sleep(1);
      // constructing object without any explicit synchronization
      DummyObject *dummy = new DummyObject();
      {
        lock_guard<mutex> guard(queue_mutex_);
        if (queue_.size() > 1000) {
          delete dummy;
          continue;
        }
        queue_.push(dummy);
      }
    }
  }

  void Consume() {
    while (true) {
      Sleep(1);
      DummyObject *dummy;
      {
        lock_guard<mutex> guard(queue_mutex_);
        if (queue_.empty())
          continue;
        dummy = queue_.front();
        queue_.pop();
      }
      // Do we have dummy object's visibility issues here?
      delete dummy;
    }
  }

 public:

  ProducerAndConsumer() {
    t1 = new thread(bind(&ProducerAndConsumer::Consume, this));
    t2 = new thread(bind(&ProducerAndConsumer::Produce, this));
  }

};

你能说这个例子是线程安全的吗？互斥锁是否强制缓存垃圾？互斥体是否提供了比内存屏障和原子更多的功能？

Answer 1

考虑到下面的代码，线程是否有可能以不同的方式看到对象的状态，尽管它们都通过相同的指针进行引用？

答案：没有。

说明：获取互斥锁是获取操作，释放是释放操作。

当dummy 被推入队列时，必须在推入之前进行构造，以便从推入线程的角度保持正确的顺序。随后发布的互斥锁将确保发出栅栏以使队列的内容（以及在此之前更改的所有其他数据）对其他线程可见。

类似地，在消费者线程中，从该线程的角度来看，从队列中分配给 dummy 的顺序将被正确排序。获取互斥体将保证DummyObject中的内存有效。

来自 §1.10.7 的支持引用：

没有关联内存位置的同步操作是栅栏，可以是获取栅栏、释放栅栏，或者同时是获取和释放栅栏。

...

例如，获取互斥锁的调用将对包含互斥锁的位置执行获取操作。相应地，释放同一个互斥体的调用将对这些相同的位置执行释放操作。