2

我目前遇到的问题是必须释放一个经常被两个不同线程访问的对象（实例）。对我来说，两个线程中的哪一个正在破坏实例并不重要，但我更喜欢那个也创建它的线程，尽管我认为这根本不重要。

因此，在应该销毁对象的线程检测到它应该被删除，并且在调用析构函数时，另一个线程正在访问该对象的成员（函数）的情况下，可能会发生某种运行时错误.

我对这个主题做了一些研究，但我只能弄清楚人们说：“为什么要删除仍然需要存在的对象”。但在我的情况下，在一个线程正在执行的一段代码决定销毁它之后，它应该不再需要了。

我将不胜感激，例如对涵盖该主题的好书或文章的提示，但请随意写下您将如何解决此问题。

4

2 回答 2

1

您需要双重间接来管理对数据的并发访问：

class Object {
    public;
    class Data {
        int get_value() const;
        void set_value(int);
    };

    class Guard {
        public:
        Guard(Nutex& mutex, Data* data) 
        :   data(data)
        {
            if( ! data) throw std::runtime_error("No Data");
            mutex.lock();
        }

        ~Guard() 
        {
            mutex.unlock();
        }

        Data& data() { return *m_data; }

        private:
        Data* data;
    };

    class ConstGuard {
        public:
        ConstGuard(Mutex& mutex, const Data* data) 
        :   data(data)
        {
            if( ! data) throw std::runtime_error("No Data");
            mutex.lock();
        }

        ~ConstGuard() 
        {
            mutex.unlock();
        }

        const Data& data() const { return *m_data; }

        private:
        const Data* data;
    };

    private:
    friend std::shared_ptr<Object> make_object(const Data&);
    Object(const Data& data)
    :   data(new Data(data))
    {}

    public:
    ~Object()
    {
        delete data;
    }

    /// Self destruction.
    void dispose() {
        Guard guard(get());
        delete data;
        data = 0;        
    }

    // For multiple operations use a Guard.
    Guard get() { return Guard(mutex, data); }
    ConstGuard get() const { return ConstGuard(mutex, data); }

    // For single operations you may provide convenience functions.
    int get_value() const { return ConstGuard(mutex, data).data().get_value(); }
    void set_value(int value) { Guard(mutex, data).data().set_value(value); }

    private:
    mutable Mutex mutex;
    data* data;
};

std::shared_ptr<Object> make_object(const Object::Data& data) {
    return std::make_shared<Object>(data);
}

（注：以上代码只是一个草图，我没有编译过）

那是一个很长的故事。简短的是 [20.7.2.5] shared_ptr 原子访问：

Concurrent access to a shared_ptr object from multiple threads does not
introduce a data race if the access is done exclusively via the functions
in this section and the instance is passed as their first argument.
  • shared_ptr atomic_load(const shared_ptr* p);
  • void atomic_store(shared_ptr* p, shared_ptr r);
  • ...但我不熟悉这些功能。
于 2013-09-26T17:31:59.157 回答
0

不应该销毁对象的线程应该使用 a 来保存它std::weak_ptr，除非它正在积极使用它。在此期间，weak_ptr可以将其升级为std::shared_ptr.

现在应该销毁它的线程可以在shared_ptr它认为合适的时间内保留它，然后将其丢弃shared_ptr。如果另一个线程只有一个weak_ptr（没有主动使用它），该对象就会消失。如果另一个线程也有shared_ptr，它会一直持有该对象，直到操作完成。

于 2013-09-27T08:39:23.443 回答