下面是实现线程安全的单例模式的更好方法，在析构函数本身释放内存。但我认为析构函数应该是可选的，因为单例实例将在程序终止时自动销毁:

#include<iostream>
#include<mutex>

using namespace std;
std::mutex mtx;

class MySingleton{
private:
    static MySingleton * singletonInstance;
    MySingleton();
    ~MySingleton();
public:
    static MySingleton* GetInstance();
    MySingleton(const MySingleton&) = delete;
    const MySingleton& operator=(const MySingleton&) = delete;
    MySingleton(MySingleton&& other) noexcept = delete;
    MySingleton& operator=(MySingleton&& other) noexcept = delete;
};

MySingleton* MySingleton::singletonInstance = nullptr;
MySingleton::MySingleton(){ };
MySingleton::~MySingleton(){
    delete singletonInstance;
};

MySingleton* MySingleton::GetInstance(){
    if (singletonInstance == NULL){
        std::lock_guard<std::mutex> lock(mtx);
        if (singletonInstance == NULL)
            singletonInstance = new MySingleton();
    }
    return singletonInstance;
}

关于我们需要使用单例类的情况可以是- 如果我们想在整个程序执行过程中维护实例的状态 如果我们参与写入应用程序的执行日志，其中只需要使用文件的一个实例....等等。 这将是值得赞赏的，如果有人可以建议在我上面的代码优化。

当初始化和object时有很多代码正在运行时，单例非常方便。例如，当你使用iBatis设置一个持久化对象时，它必须读取所有的配置，解析映射，确保它是正确的，等等。在开始编写代码之前。

如果每次都这样做，性能会大大降低。在单例中使用它，你只执行一次命中，然后所有后续调用都不必执行它。

关于模式有一点:不要一概而论。当他们有用的时候，当他们失败的时候，他们有所有的情况。

当您必须测试代码时，单例可能会令人讨厌。您通常只能使用类的一个实例，并且可以选择在构造函数中打开一扇门或使用一些方法来重置状态等等。

另一个问题是，Singleton实际上只不过是一个伪装的全局变量。当你的程序有太多的全局共享状态时，事情往往会倒退，我们都知道这一点。

这可能会使依赖追踪更加困难。当所有事情都依赖于你的单例时，就很难改变它，拆分为两个等等。你通常会被它困住。这也妨碍了灵活性。研究一些依赖注入框架来缓解这个问题。

第一个例子不是线程安全的——如果两个线程同时调用getInstance，这个静态将是一个PITA。某种形式的互斥会有所帮助。

另一个实现

class Singleton
{
public:
    static Singleton& Instance()
    {
        // lazy initialize
        if (instance_ == NULL) instance_ = new Singleton();

        return *instance_;
    }

private:
    Singleton() {};

    static Singleton *instance_;
};

在桌面应用程序中(我知道，只有我们这些恐龙才会写这些!)，它们对于获得相对不变的全局应用程序设置是必不可少的——用户语言，帮助文件的路径，用户首选项等等，否则就必须传播到每个类和每个对话框中。

编辑-当然这些应该是只读的!