访问shared\u ptr持有的类的原子成员

我正在尝试创建一个小类,它将允许我促进两个线程之间的通信。

当这些线程在线程池中排队时,它们很可能会超过创建上述类的上下文。

到目前为止我所尝试的( on coliru as well ):

class A    
{
public:
    A(int maxVal) : maxValue(maxVal) {}    
    bool IsOverMax() const { return cur >= maxValue; }    
    void Increase() { cur++; }

private:
    const int  maxValue;    
    atomic_int cur{ 0 };
};

可能的用途:

void checking(const shared_ptr<A> counter)
{
    while(!counter->IsOverMax())
    {
        cout<<"Working\n";         // do work
        std::this_thread::sleep_for(10ms);
    }
}

void counting(shared_ptr<A> counter)
{
    while (!counter->IsOverMax())
    {
        cout<<"Counting\n";
        counter->Increase(); // does this fall under `...uses a non-const member function of shared_ptr then a data race will occur`?  http://en.cppreference.com/w/cpp/memory/shared_ptr/atomic
        std::this_thread::sleep_for(9ms);
    }
}

int main() 
{ 

    unique_ptr<thread> t1Ptr;
    unique_ptr<thread> t2Ptr;

    {
        auto aPtr = make_shared<A>(100); // This might be out of scope before t1 and t2 end
        t1Ptr.reset(new thread(checking, aPtr)); // To simbolize that t1,t2 will outlive the scope in which aPtr was originaly created
        t2Ptr.reset(new thread(counting, aPtr));
    }

    t2Ptr->join();
    t1Ptr->join();
    //cout<< aPtr->IsOverMax();
}

我担心的原因是 documentation 说:

如果多个执行线程访问同一个std::shared\u ptr对象而不进行同步,并且其中任何一个访问都使用 shared\u ptr的非常量成员函数,则将发生数据竞争 除非所有此类访问都是通过这些函数执行的,这些函数是相应原子访问函数的重载(std::atomic\u load、std::atomic\u store等)

• 所以 Increase 是一个非常量函数,aPtr的副本是 the same std::shared_ptr 是否适用于这种情况?
• 这段代码是线程安全的吗?
• 对于非原子对象(比如使用std::mutex锁定对常规int的读写),这可以吗?
• 无论如何,为什么?