单例模式

单例模式：

在实现单例模式之前需要先了解一下静态(全局/局部)变量的初始化方式：

全局变量、non-local static 变量（文件域的静态变量和类的静态成员变量）在main执行之前就已分配内存并初始化；local static 变量（局部静态变量）同样是在 main 前就已分配内存，第一次使用时初始化

非局部静态变量一般在 main 执行之前的静态初始化过程中分配内存并初始化，可以认为是线程安全的

C++11 保证静态局部变量的初始化过程是线程安全的

 

设计模式经典GoF定义的单例模式需要满足以下两个条件：

1）保证一个类只创建一个实例
2）提供对该实例的全局访问点

 

在设计单例模式时有亮点需要注意：

单例模式的实现分懒汉模式和饿汉模式以及是否线程安全

 

懒汉模式和饿汉模式的区别：

懒汉模式中，直到 Instance() 被访问，才会生成实例，这种特性被称为延迟初始化（Lazy Initialization），这在一些初始化时消耗较大的情况有很大优势。 

饿汉模式中，在编译器初始化的时候就完成了实例的创建，和上述的 Lazy Singleton 相反

 

实现1：

懒汉模式，非线程安全，堆内存

#include <iostream>
#include <vector>
using namespace std;

class Singelton {
private:
    static Singelton *singel;
    //将默认构造函数、析构函数定义为私有的
    //其它拷贝控制函数定义为删除的(因为这个代码中我们只需要执行默认构造即可)
    Singelton(){}
    Singelton(const Singelton&) = delete;
    Singelton& operator=(const Singelton&) = delete;
    ~Singelton(){}//将析构函数声明成private，防止被意外delete

public:
    static Singelton* GetInstance() {
        //非线程安全
        //如果有多个线程同时进行singel == nullptr判断，则会创建多个实例
        if(singel == nullptr) singel = new Singelton();
        return singel;
    }
};

//类静态成员需要类外初始化
Singelton* Singelton::singel = nullptr;

int main(void) {
    // Singelton cnt;//error,访问私有的默认构造函数

    Singelton *s1 = Singelton::GetInstance();
    Singelton *s2 = Singelton::GetInstance();

    cout << s1 << endl;
    cout << s2 << endl;

// 输出：
// 0x28053f8
// 0x28053f8

    return 0;
}

第一次访问 GetInstance 时才创建实例，显然是懒汉模式。如果有多个线程同时进行 singel == nullptr 判断，则会创建多个实例，所以其是非线程安全的。并且该实现中一旦创建了实例，是不可删除的

还有一个问题是 GetInstance 为啥是 static 的：如果 GetInstance 被定义为非静态函数的话，要访问 GetInstance 则必须先创建一个实例，而要在访问 GetInstance 之前创建实例则说明该类可以创建多个实例，这显然不符合单例模式的条件

 

针对实现1中的非线程安全问题，我们可以给 if 语句加个锁

实现2：

懒汉模式，线程安全，堆内存

#include <iostream>
#include <vector>
#include <mutex>
using namespace std;

class Singelton {
private:
    static std::mutex mtex;//静态锁
    static Singelton *singel;
    //将默认构造函数、析构函数定义为私有的
    //其它拷贝控制函数定义为删除的(因为这个代码中我们只需要执行默认构造即可)
    Singelton(){}
    Singelton(const Singelton&) = delete;
    Singelton& operator=(const Singelton&) = delete;
    ~Singelton(){}//将析构函数声明成private，防止被意外delete

public:
    static Singelton* GetInstance() {//注意,在静态成员函数中中只能直接使用静态数据成员
        mtex.lock();
        if(singel == nullptr) singel = new Singelton();
        mtex.unlock();

        return singel;
    }
};

//类静态成员需要类外初始化
Singelton* Singelton::singel = nullptr;
std::mutex Singelton::mtex;

int main(void) {
    // Singelton cnt;//error,访问私有的默认构造函数

    Singelton *s1 = Singelton::GetInstance();
    Singelton *s2 = Singelton::GetInstance();

    cout << s1 << endl;
    cout << s2 << endl;

// 输出：
// 0x28053f8
// 0x28053f8

    return 0;
}

注意：加锁是比较费时的，而按照上面的实现，每一次访问 Getlnstance 函数都要加/解锁一次，而实际上我们只需要在创建第一个实例时加锁。显然我们可以在加锁之前先判断一下是否已经创建了实例，从而避免已经创建了实例的情况下加/解锁。即双检测锁模式

 

据上面的分析有

实现3：

懒汉模式，线程安全，堆内存

#include <iostream>
#include <vector>
#include <mutex>
using namespace std;

class Singelton {
private:
    static std::mutex mtex;//静态锁
    static Singelton *singel;
    //将默认构造函数、析构函数定义为私有的
    //其它拷贝控制函数定义为删除的(因为这个代码中我们只需要执行默认构造即可)
    Singelton(){}
    Singelton(const Singelton&) = delete;
    Singelton& operator=(const Singelton&) = delete;
    ~Singelton(){}//将析构函数声明成private，防止被意外delete

public:
    static Singelton* GetInstance() {//注意,在静态成员函数中中只能直接使用静态数据成员
        //双检测锁模式
        if(singel == nullptr){
            mtex.lock();
            if(singel == nullptr) singel = new Singelton();
            mtex.unlock();
        }
        return singel;
    }
};

//类静态成员需要类外初始化
Singelton* Singelton::singel = nullptr;
std::mutex Singelton::mtex;

int main(void) {
    // Singelton cnt;//error,访问私有的默认构造函数

    Singelton *s1 = Singelton::GetInstance();
    Singelton *s2 = Singelton::GetInstance();

    cout << s1 << endl;
    cout << s2 << endl;

// 输出：
// 0x28053f8
// 0x28053f8

    return 0;
}

 

由于 C++11 保证静态局部变量的初始化过程是线程安全的特性，我们也可以通过静态局部变量来实现线程安全

实现4：

懒汉模式，线程安全，自由存储区

#include <iostream>
#include <vector>
using namespace std;

class Singelton {
private:
    Singelton(){}//将默认构造函数定义为私有的
    Singelton(const Singelton&) = delete;
    Singelton& operator=(const Singelton&) = delete;
    ~Singelton(){}

public:
    static Singelton* GetInstance() {
        //c++11开始，局部静态变量的初始化过程是线程安全的
        static Singelton instance;//静态变量的生命周期是全局的，所以可以返回局部静态变量的引用
        return &instance;
    }
};

int main(void) {
    // Singelton cnt;//error,访问私有的默认构造函数

    Singelton *s1 = Singelton::GetInstance();
    Singelton *s2 = Singelton::GetInstance();

    cout << s1 << endl;
    cout << s2 << endl;

// 输出：
// 0x2b853d8
// 0x2b853d8

    return 0;
}

 

实现5：

饿汉模式，线程安全，自由存储区

#include <iostream>
#include <vector>
using namespace std;

class Singelton {
private:
    static Singelton instance;
    Singelton(){}//将默认构造函数定义为私有的
    Singelton(const Singelton&) = delete;
    Singelton& operator=(const Singelton&) = delete;
    ~Singelton(){}

public:
    static Singelton* GetInstance() {
        return &instance;
    }
};

//类外声明类静态数据成员
Singelton Singelton::instance;//在mian之前初始化

int main(void) {
    // Singelton cnt;//error,访问私有的默认构造函数

    Singelton *s1 = Singelton::GetInstance();
    Singelton *s2 = Singelton::GetInstance();

    cout << s1 << endl;
    cout << s2 << endl;

// 输出：
// 0x489008
// 0x489008

    return 0;
}

注意：饿汉模式是在 main 之前初始化的，自动满足线程安全