使用std :: unique_ptr的带有私有析构函数的Singleton

Question

我在程序中创建了所有单例,并记住了该文档:http: //erdani.com/publications/DDJ_Jul_Aug_2004_revised.pdf (如果有人想知道为什么单身人士,他们都是工厂,其中一些存储了一些全局设置他们应该如何创建实例).

他们每个人看起来都像这样:

宣言:

class SingletonAndFactory {
    static SingletonAndFactory* volatile instance;

public:
    static SingletonAndFactory& getInstance();

private:
    SingletonAndFactory();

    SingletonAndFactory(
        const SingletonAndFactory& ingletonFactory
    );

    ~SingletonAndFactory();
};

定义:

boost::mutex singletonAndFactoryMutex;

////////////////////////////////////////////////////////////////////////////////

// class SingletonAndFactory {

SingletonAndFactory* volatile singletonAndFactory::instance = 0;

// public:

SingletonAndFactory& SingletonAndFactory::getInstance() {
    // Singleton implemented according to:
    // "C++ and the Perils of Double-Checked Locking".
    if (!instance) {
        boost::mutex::scoped_lock lock(SingletonAndFactoryMutex);
        if (!instance) {
            SingletonAndFactory* volatile tmp = (SingletonAndFactory*) malloc(sizeof(SingletonAndFactory));
            new (tmp) SingletonAndFactory; // placement new
            instance = tmp;
        }
    }
    return *instance;
}

// private:

SingletonAndFactory::SingletonAndFactory() {}

// };

暂时搁置单身人士的设计是最好的(因为它会开始一场毫无意义的火焰战争)我的问题是:用std :: unique_ptr替换普通指针会对我有利吗？特别是,它会在程序退出时调用singleton的析构函数吗？如果是这样,我将如何实现它？当我试图添加类似的东西friend class std::unique_ptr<SingletonAndFactory>;时没有解决,因为编译器继续抱怨析构函数是私有的.

我知道在我目前的项目中没有关系,因为没有一家工厂有需要清理的东西,但为了将来参考,我想知道如何实现这种行为.

Answer 1

unique_ptr删除的不是它本身，而是删除者。因此，如果您想采用该friend方法，则必须这样做：

friend std::unique_ptr<SingletonFactory>::deleter_type;

但是，我认为不能保证默认删除器不会将实际删除器委托delete给另一个函数，这会破坏这一点。

相反，您可能想提供自己的删除器，也许像这样：

class SingletonFactory {
    static std::unique_ptr<SingletonFactory, void (*)(SingletonFactory*)> volatile instance;

public:
    static SingletonFactory& getInstance();

private:
    SingletonFactory();

    SingletonFactory(
        const SingletonFactory& ingletonFactory
    );

    ~SingletonFactory();

    void deleter(SingletonFactory *d) { d->~SingletonFactory(); free(d); }
};

在创建函数中：

SingletonFactory* volatile tmp = (SingletonFactory*) malloc(sizeof(SingletonFactory));
new (tmp) SingletonFactory; // placement new
instance = decltype(instance)(tmp, &deleter);

Answer 2

在C++ 11中,您可以使用本地静态保证程序结束时的线程安全延迟初始化和破坏:

SingletonAndFactory& SingletonAndFactory::getInstance() {
    static SingletonAndFactory instance;
    return instance;
}

请注意,这仍然会导致生命周期问题,因为它可能会在其他静态对象之前被销毁.如果他们试图从他们的析构函数访问它,那么你将遇到麻烦.

在此之前,这是不可能的(尽管许多编译器保证了上述内容).如您链接到的文档中所述,volatile与线程同步无关,因此您的代码具有数据争用和未定义的行为.选项包括:

• 获取锁定的(可能很大的)性能命中来检查指针
• 使用编译器提供的任何非可移植原子内在函数来测试指针
• 忘记线程安全的初始化,并确保在启动线程之前初始化它
• 不要使用单身人士

我赞成最后一个选项,因为它解决了Singleton反模式引入的所有其他问题.