单例模式：类只有一个实例，且全局可访问。单例模式中最大的缺陷就是线程安全与判断的开销。

       定义一个单例类，使用类的私有静态指针变量指向类的唯一实例，并用一个公有的静态方法获取该实例。

       单例模式通过类本身来管理其唯一实例，这种特性提供了解决问题的方法。唯一的实例是类的一个普通对象，但设计这个类时，让它只能创建一个实例并提供对此实例的全局访问。唯一实例类Singleton在静态成员函数中隐藏创建实例的操作。习惯上把这个成员函数叫做Instance()，它的返回值是唯一实例的指针。

饿汉模式

       饿汉模式是指类在加载时候就创建单例的对象。

#include 
using namespace std;

class Singleton{
public:
    static Singleton* getInstance(){
        return instance;    
    }
private:
    Singleton(){}
    static Singleton* instance;
};
Singleton* Singleton::instance = new Singleton();
1
2
3
4
5
6
7
8
9
10
11
12
13

懒汉模式(线程不安全)

       懒汉模式是指在使用时候才创建单例的对象。获取实例的时候先判断实例是否为空，为空则创建实例并返回这个实例，否则返回已创建的实例。

#include 
using namespace std;

class Singleton{
public:
    static Singleton* getInstance(){
        if(instance == NULL) //与饿汉模式的区别
            instance = new Singleton();
        return instance;    
    }
private:
    Singleton(){}
    static Singleton* instance;
};
Singleton* Singleton::instance = nullptr;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

加锁的懒汉模式（线程安全）

如果多个线程同时进入 getInstance() 时候，实例都为空的话，则各自都会创建实例。很容易想到的一个方法就是加锁保证线程安全。

#include 
#include 
using namespace std;

class Singleton{
public:
    static Singleton* getInstance(){
        if(instance == nullptr){
            m_mutex.lock();
            instance = new Singleton();
            m_mutex.unlock();
        } 
        return instance;
    } 
private:
    Singleton(){}
    static Singleton* instance;
    static std::mutex m_mutex;
};
Singleton* Singleton::instance = nullptr;
//std::mutex Singleton::m_mutex;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Meyers 单例模式

单例对象使用局部静态变量的方法，从而延迟到调用时实例化

class Singleton{
public:
    static Singleton& getInstance(){
        static Singleton instance;
        return instance;
    }
private:
    Singleton(){};
};

1
2
3
4
5
6
7
8
9
10