单件模式（Sginleton Pattern）

单件模式：用来创建独一无二的，只能有一个实例的对象。将使用和构造分离。

线程池（threadpool）、缓存（cache）、对话框、处理器、注册表对象、日志对象、打印机驱动程序对象、显卡设备驱动程序对象。
单件模式确保一个类之哟一个实例，并提供一个全局访问点。

意图: 希望对象只有一个实例，单没有控制对象实例化的全局对象。还希望确保所有实体使用该对象相同的实例，无需将引用传给它们。
问题来了（多线程）：
Double-Checked Locking 双重加锁模式

在C++中，可能会导致内存泄漏—-创建了两个对象，销毁时，只销毁了其中一个。

线程同步：

public class Singleton{
    // 静态初始化器（static initializer）中创建单件，保证了线程安全。
    private static Singleton uniqueInstance;
    private Singleton(){}
    public static synchronized Singleton getInstance(){
        if(uniqueInstance == null)
            uniqueInstance = new Singleton();
        return uniqueInstance;
    }
}

但是每次执行都要先同步，判断对象是否存在，这样会严重影响性能。

public class Singleton{
    private volatile static Singleton uniqueInstance;
    private Singleton(){}
    private static Singleton getInstance(){
        if(uniqueInstance = null){
            //synchronized (Singleton.class){
            synchronized (this){
                if (uniqueInstance = null)
                    uniqueInstance = new Singleton();
            }
        }
    }
}

当两个线程都运行到if(uniqueInstance = null)时候，都会执行下一句。等待同步。此句最多执行一次。(《Effective C++》、《More Effective C++》)
C++ Singleton design pattern

class S
{
    public:
        static S& getInstance()
        {
            static S    instance; // Guaranteed to be destroyed.
                                  // Instantiated on first use.
            return instance;
        }
    private:
        S() {};                   // Constructor? (the {} brackets) are needed here.

        // C++ 03
        // ========
        // Dont forget to declare these two. You want to make sure they
        // are unacceptable otherwise you may accidentally get copies of
        // your singleton appearing.
        S(S const&);              // Don't Implement
        void operator=(S const&); // Don't implement

        // C++ 11
        // =======
        // We can use the better technique of deleting the methods
        // we don't want.
    public:
        S(S const&)               = delete;
        void operator=(S const&)  = delete;

        // Note: Scott Meyers mentions in his Effective Modern
        //       C++ book, that deleted functions should generally
        //       be public as it results in better error messages
        //       due to the compilers behavior to check accessibility
        //       before deleted status
};

单例模式（C++）：

class StringSingleton
{
public:
    // Some accessor functions for the class, itself
    std::string GetString() const {return mString; }
    void SetString( const std::string & newString) { mString = newStr ; }

     // The magic function, which allows access to the class from anywhere
     // To get the value of the instance of the class, call:
     //     StringSingleton::Instance().GetString();
      static StringSingleton &Instance()
     {
         // This line only runs once, thus creating the only instance in existence
         static StringSingleton *instance = new StringSingleton;
         // dereferencing the variable here, saves the caller from having to use 
         // the arrow operator, and removes temptation to try and delete the 
         // returned instance.
         return *instance; // always returns the same instance
     }

 private: 
     // We need to make some given functions private to finish the definition of the singleton
     StringSingleton(){} // default constructor available only to members or friends of this class

     // Note that the next two functions are not given bodies, thus any attempt 
     // to call them implicitly will return as compiler errors. This prevents 
     // accidental copying of the only instance of the class.
     StringSingleton(const StringSingleton &old); // disallow copy constructor
     const StringSingleton &operator=(const StringSingleton &old); //disallow assignment operator

     // Note that although this should be allowed, 
     // some compilers may not implement private destructors
     // This prevents others from deleting our one single instance, which was otherwise created on the heap
     ~StringSingleton(){} 
 private: // private data for an instance of this class
     std::string mString;
}

互斥锁（C++）

#include <iostream>
using namespace std;

/* Place holder for thread synchronization mutex */
class Mutex
{   /* placeholder for code to create, use, and free a mutex */
};

/* Place holder for thread synchronization lock */
class Lock
{   public:
        Lock(Mutex& m) : mutex(m) { /* placeholder code to acquire the mutex */ }
        ~Lock() { /* placeholder code to release the mutex */ }
    private:
        Mutex & mutex;
};

class Singleton
{   public:
        static Singleton* GetInstance();
        int a;
        ~Singleton() { cout << "In Destructor" << endl; }

    private:
        Singleton(int _a) : a(_a) { cout << "In Constructor" << endl; }


        static Mutex mutex;

        // Not defined, to prevent copying
        Singleton(const Singleton& );
        Singleton& operator =(const Singleton& other);
};

Mutex Singleton::mutex;

Singleton* Singleton::GetInstance()
{
    Lock lock(mutex);

    cout << "Get Instance" << endl;

    // Initialized during first access
    static Singleton inst(1);

    return &inst;
}

int main()
{
    Singleton* singleton = Singleton::GetInstance();
    cout << "The value of the singleton: " << singleton->a << endl;
    return 0;
}