c++ - 在普通对象安全的任何上下文中，原子对象是否不安全？

Question

我的问题很简单:是否有使用普通类型对象的并行算法 T是合法和安全的(定义明确，保证有效)并使用 std::atomic<T> 代替对象导致未指定或未定义的行为？ 换句话说，非原子类型有可能提供比原子类型更强的保证吗？

当它们对常规对象有效时，是否所有内存可见性保证都对原子对象有效？

[这意味着编译器可以同样对待(宽松的)原子操作和非原子操作，从而简化中间表示。]

如果是，是否可以正式证明？

当然类型T这样 std::atomic<T>不是 std::atomic 的有效特化不算。

Answer 1

与 atomic 等效值相比，非原子值没有更强的保证。

我能想到的唯一不好的模式是，当开发人员错误地假设如果一个数据结构的所有成员都是单独线程安全的，那么整个数据结构就被认为是线程安全的。这不是一个正确的假设。

考虑以下假设:

class Volume
{
    atomic<int> _width;
    atomic<int> _height;
    atomic<int> _depth;
public:
   int computeValue() {return (_width*_height*_depth);}
   void SetInternals(int w, int h, int d) {_height=h;_width=w;_depth=d;}
};

线程 1 执行此操作的位置:

f->SetInternals(42, 100, 200);

线程 2 同时执行此操作。

int something_important = f->computeValue();

您可以看到，如果两个线程同时执行，computeValue 返回的值可能会损坏。

您可以使用互斥锁和锁组合而不是原子来实现所需的线程安全行为:

class Volume
{
    int _width;
    int _height;
    int _depth;
    mutex _mutex;
public:
   int computeValue() {
        lock_guard<mutex> lck(_mutex);
        int result = _width*_height*_depth;
        return result;
   }
   void SetInternals(int w, int h, int d) {
      lock_guard<mutex> lck(_mutex);
      _height=h;_width=w;_depth=d;
   }
};