原子容器的 C++11 线程安全

Question

我正在尝试实现一个没有互斥锁的线程安全 STL 向量。所以我通过this 发布并为原子原语实现了一个包装器。

但是，当我运行下面的代码时，它从下面的代码中显示了Failed!twice（只有两个竞争条件实例），因此它似乎不是线程安全的。我想知道我该如何解决这个问题？

包装类

template<typename T>
struct AtomicVariable
{
    std::atomic<T> atomic;

    AtomicVariable() : atomic(T()) {}

    explicit AtomicVariable(T const& v) : atomic(v) {}
    explicit AtomicVariable(std::atomic<T> const& a) : atomic(a.load()) {}

    AtomicVariable(AtomicVariable const&other) : 
        atomic(other.atomic.load()) {}

    inline AtomicVariable& operator=(AtomicVariable const &rhs) {
        atomic.store(rhs.atomic.load());
        return *this;
    }

    inline AtomicVariable& operator+=(AtomicVariable const &rhs) {
        atomic.store(rhs.atomic.load() + atomic.load());
        return *this;
    }

    inline bool operator!=(AtomicVariable const &rhs) {
        return !(atomic.load() == rhs.atomic.load());
    }
};

typedef AtomicVariable<int>    AtomicInt;

函数和测试

// Vector of 100 elements.
vector<AtomicInt> common(100, AtomicInt(0));

void add10(vector<AtomicInt> &param){
    for (vector<AtomicInt>::iterator it = param.begin();
        it != param.end(); ++it){
        *it += AtomicInt(10);
    }
}

void add100(vector<AtomicInt> &param){
    for (vector<AtomicInt>::iterator it = param.begin();
        it != param.end(); ++it){
        *it += AtomicInt(100);
    }
}

void doParallelProcessing(){

    // Create threads
    std::thread t1(add10, std::ref(common));
    std::thread t2(add100, std::ref(common));

    // Join 'em
    t1.join();
    t2.join();

    // Print vector again
    for (vector<AtomicInt>::iterator it = common.begin();
        it != common.end(); ++it){
        if (*it != AtomicInt(110)){
            cout << "Failed!" << endl;
        }
    }
}


int main(int argc, char *argv[]) {

    // Just for testing purposes
    for (int i = 0; i < 100000; i++){
        // Reset vector
        common.clear();
        common.resize(100, AtomicInt(0));
        doParallelProcessing();
    }
}

有没有像原子容器这样的东西？我还用常规的vector<int> 对此进行了测试，它没有任何Failed 输出，但这可能只是巧合。

Answer 1

只需将运算符 += 写为：

    inline AtomicVariable& operator+=(AtomicVariable const &rhs) {
        atomic += rhs.atomic;
        return *this;
    }

在文档中：http://en.cppreference.com/w/cpp/atomic/atomic operator += 是原子的。

你的例子失败了，因为下面的执行场景是可能的：

1. Thread1 - rhs.atomic.load() - 返回 10 ； Thread2 - rhs.atomic.load() - 返回 100
2. Thread1 - atomic.load() - 返回 0 ； Thread2 - atomic.load - 返回 0
3. Thread1 - 添加值 (0 + 10 = 10) ; Thread2 - 添加值 (0 + 100)
4. Thread1 - atomic.store(10) ； Thread2 - atomic.store(100)

最后在这种情况下，原子值可能是 10 或 100，取决于哪个线程首先执行 atomic.store。

Answer 2

请注意

           atomic.store(rhs.atomic.load() + atomic.load());

不是原子的

您有两种选择来解决它。 记忆 1) 使用互斥锁。

EDIT 正如 cmets 中提到的 T.C，这是无关紧要的，因为这里的操作将是 load() 然后 load() 然后 store() （不是放松模式） - 所以这里的内存顺序不相关.

2) 使用内存顺序http://bartoszmilewski.com/2008/12/01/c-atomics-and-memory-ordering/

memory_order_acquire：保证后续加载不会在当前加载或任何先前加载之前移动。 memory_order_release：前面的存储不会移过当前存储或任何后续存储。

我仍然不确定 2，但我认为如果商店不并行，它会起作用。