重新创建基于 shared_ptr 的单例

Question

有一个static shared_ptr<MyClass> get() 内部有一个weak_ptr，它使用ptr.lock() 提供共享指针。

当ptr.lock() 给出一个空指针时，应该再次创建单例。

但是它是否保证（它不）前一个单例的析构函数已经完成？对此有什么办法？

Answer 1

但是它是否保证（它不）前一个单例的析构函数已经完成？对此能做些什么？

这是一个不寻常的请求，但我知道如果您正在控制外部单例资源，它可能是必要的。

这是我的解决方案。

确保在生产中使用前彻底检查

#include <memory>
#include <mutex>
#include <condition_variable>

struct tricky_object
{

};


class tricky_cache
{
    struct statics {
        std::mutex _m;
        std::condition_variable _deleted;
        bool _exists = false;
        std::weak_ptr<tricky_object> _cache;
    };

    static statics& get() {
        static statics _;
        return _;
    }

public:
    static
    std::shared_ptr<tricky_object> acquire()
    {
        // get static data
        auto& data = get();

        // lock the cache's mutex
        auto lock = std::unique_lock<std::mutex>(data._m);
        std::shared_ptr<tricky_object> candidate;

        // wait on the condition variable for the following conditions to be true:
        data._deleted.wait(lock, [&data, &candidate] {

            // either the object is in play and we have acquired another reference...
            candidate = data._cache.lock();
            if (candidate)
                return true;

            // ... or (if not) the previous object is actually dead and buried.
            return !data._exists;
        });

        // at this point we still own the lock and wait must have returned true, so...
        // if we own the candidate then it was already in play
        if (candidate)
            return candidate;

        // otherwise the previous object is certainly destroyed and we may create another
        data._cache = candidate = std::shared_ptr<tricky_object>(new tricky_object(),
                                                            [&data](tricky_object*p) {
                                                                // but the custom deleter needs some trickery
                                                                delete p;
                                                                if (p) {
                                                                    auto lock = std::unique_lock<std::mutex>(data._m);
                                                                    data._exists = false;
                                                                    lock.unlock();
                                                                    data._deleted.notify_all();
                                                                }
                                                            });
        // and we should record the fact that the object now exists...
        data._exists = true;
        lock.unlock();
        // ... and inform all waiters that they may continue acquiring
        data._deleted.notify_all();
        return candidate;
    }
};


int main()
{
    auto p = tricky_cache::acquire();

    return 0;
}

Answer 2

对此可以做些什么？停止使用糟糕的编程风格。

如果你要使用单例，那么它应该是一个单例：一个实例，句号。不需要用智能指针来管理它的生命周期；它总是在那里。销毁它只是为了以后重新创建它有什么意义？特别是如果没有为娱乐功能提供特殊参数以便以后重新创建它？

但是，对于您的问题：

它是否保证（它不）前一个单例的析构函数已经完成

这有关系吗？为了启动对象的析构函数，shared_ptr 对该对象的引用计数必须为零。所以weak_ptr 已经是空的了。对象的生命周期在其析构函数开始 时结束（就像对象的生命周期在其构造函数完成时开始）。所以单例本身已经被销毁了；你只是在做清理工作。

所以在旧实例的析构函数的调用栈中创建一个新的单例实例是没有问题的。它根本不会访问自己。

线程

在多线程环境中，如果没有在返回/创建单例的get 函数中使用某种锁，这种接口已经被严重破坏了。如果没有这种互斥，多个线程可能会尝试同时创建单例，这可能会导致构建多个单例实例。

对于单例本身的资源，这些资源的释放必须已经受到某种形式的互斥机制的约束。资源本身是单例的唯一时间。但与我们所说的单例不同，它不能被多段代码拥有。

在这种情况下，您的单身人士根本不应该拥有该资源的所有权。它可以引用它，但不能销毁或创建它。