c++ - 以线程安全的方式与外界共享一个数据成员

Question

如果能就此问题提出建议，我将不胜感激。

例如

class Foo
{
    TData data;
public:
    TData *getData() { return &data; } // How can we do this in a thread safe manner ?
};

所以我想有一种机制使 getData() 线程安全。我提出了自己的解决方案，其中涉及将数据成员打包到以下模板类中，并使用一个互斥锁来同步对它的访问。你怎么认为 ？可能会出现什么问题？

class locked_object : boost::noncopyable
{
    T *object;
    TLockable *lock;
    bool locked;

public:
    locked_object(T *_object, TLockable *_lock) : object(_object), lock(_lock), locked(true)
    {
        lock->lock();
    }

    ~locked_object()
    {
        lock->unlock();
    }

    T *get()
    {
        _ASSERT(locked);
        if (!locked)
            throw new std::exception("Synchronization error ! Object lock is already released !");
        return this->tobject;
    }


    void unlock()
    {
        locked = false;

        lock->unlock();
    }

    T *operator ->() const
    {   
        _ASSERT(locked);
        if (!locked)
            throw new std::exception("Synchronization error ! Object lock is already released !");

        return this->tobject; 
    }

    operator T *() const
    {
        _ASSERT(locked);
        if (!locked)
            throw new std::exception("Synchronization error ! Object lock is already released !");

        return this->tobject;
    }
};

感谢您提前提出任何评论和意见。

法提赫

Answer 1

你听说过The Law of Demeter吗？ ？

有一个类似的建议(我认为来自 Sutter):不要分享对你内部的引用

两者都是为了避免耦合，因为通过共享对内部的引用，这意味着您的公共(public)接口(interface)会泄露实现细节。

既然这么说了，你的界面就不行了。

问题是你锁定的是代理，而不是对象:我仍然可以通过多个路径访问:

• 来自 Foo，不需要互斥 --> 哎呀？
• 来自两个不同的locked_object --> 这似乎不是故意的...

更重要的是，一般来说，您不能锁定一个对象的单个部分，因为这样您就无法拥有整个对象的事务语义。