2

我可以使用这个类包装器对对象进行线程安全访问，并且所需的行为符合 C++11 吗？

琴弦的主要重音：

T* operator->() {

和

T& operator*() {

注意，我知道这里最适合使用 std::atomic<> 作为整数（int），但在这段代码中，我们可以使用任何其他对象而不是 int。

2.0 版通过使用执行指针习语：

#include<thread>
#include<mutex>
#include<memory>
#include<iostream>
#include<vector>

template<typename T>
class safe_obj {
    T obj;
    mutable std::mutex mtx;
    safe_obj(safe_obj<T> &) {}
    safe_obj<T>& operator=(safe_obj<T> &) {}

    class T_exclusive_lock {
         std::unique_lock<std::mutex> xlock;
    public:
         T*const self;
         T_exclusive_lock(T * const s, std::mutex& _mtx)
             :self(s), xlock(_mtx) {}

        T* operator -> () const {return self;}
        operator T&()  {return *self;}

        friend std::ostream& operator << (std::ostream &stream, T_exclusive_lock &obj) {
            stream << obj;
            return stream;
        }
    };

public:
    template<typename  Types>
    safe_obj(Types  args) : obj(args ) 
    { }

    T_exclusive_lock operator->() {
        return T_exclusive_lock(&obj, mtx);
    }    

    T_exclusive_lock* operator*() {
        return &T_exclusive_lock(&obj, mtx);
    }       
};

int main() {
    safe_obj<std::shared_ptr<int> > safe_int( std::make_shared<int>(10) );   

    auto lambda = [&safe_int]() {
        std::cout << safe_int->use_count() << std::endl;    // is that thread-safe? 
        std::cout << *safe_int << std::endl;    // is that thread-safe? 
        std::cout << *safe_int->get() << std::endl;    // is that thread-safe? 
    };

    std::vector<std::thread> thr_grp;
    for(size_t i = 0; i < 10; ++i) thr_grp.emplace_back(std::thread(lambda));
    for(auto &i : thr_grp) i.join();

    int b; std::cin >> b;
    return 0;
}
4

3 回答 3

8

您提供的原始代码不保证任何线程安全。std::unique_lock一旦超出范围，您的 s 就会解锁互斥锁，这是在使用您要保护的对象之前。

为了达到预期的结果，您需要声明另一个模板类（例如locked_obj<T>），它表示处于锁定状态的对象（通过unique_lock在safe_obj的互斥体上设置 a ）并从重载的运算符中返回这样的对象。这样的对象将是一个临时对象，并允许您在locked_obj. 由于临时对象一直存在到当前语句的末尾，因此使用此类safe_objs 将大部分是透明的。

这种技术是循环执行指针习语的一种应用。

于 2013-08-24T14:47:06.860 回答
3

锁定单个函数或锁定对单个对象的访问并不能保证线程安全；根据程序的不同，许多操作需要对同一对象进行多次函数调用而不会中断或对多个对象进行操作而不会中断。线程安全必须设计到应用程序中；没有库黑客可以使设计不当的应用程序成为线程安全的。

于 2013-08-24T17:37:57.293 回答
2

不，这不是线程安全的。到访问器函数返回时，互斥锁已解锁，因此对对象的访问未同步。

一种方法是重载赋值和转换运算符：

safe_obj & operator=(T const &t) {
    std::unique_lock<std::mutex> lock(mtx);
    obj = t;
    return *this;
}

operator T() {
    std::unique_lock<std::mutex> lock(mtx);
    return obj;
}

但是，如果您想提供所有复合赋值运算符，这可能会变得乏味，并且如果对象不可复制，则转换运算符将不起作用。

另一种方法是返回一个包含 a 的访问器对象unique_lock，只要您可以访问该对象，它就会使互斥锁保持锁定状态。

于 2013-08-24T14:49:38.090 回答