通俗易懂的单例模式讲解（懒汉、饿汉）

1.懒汉：

        顾名思义，不到万不得已就不会去实例化类，也就是说在第一次用到类实例的时候才会去实例化。懒汉本身是线程不安全的

        在访问量较小时，采用懒汉实现。这是以时间换空间。

2.饿汉：

       饿了肯定要饥不择食。所以在单例类定义的时候就进行实例化。本身就是线程安全的

       由于要进行线程同步，所以在访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。

1.懒汉：

//1.常规懒汉模式
#include <iostream>
#include <process.h>
#include <windows.h>
using namespace std;
 
class Singelton{
private:
    Singelton();
    static Singelton *single;
public:
    static Singelton *GetSingelton();
};

 
Singelton *Singelton::single = nullptr;
Singelton *Singelton::GetSingelton(){
    if(single == nullptr){
        single = new Singelton;
    }
    return single;
}

//2.线程安全的懒汉模式

class singleton
{
protected:
    singleton()
    {
        // 初始化
        pthread_mutex_init(&mutex);
    }
private:
    static singleton* p;
public:
    static pthread_mutex_t mutex;
    static singleton* initance();
};
 

pthread_mutex_t singleton::mutex;
singleton* singleton::p = NULL;
//下面进行的两次if(p == NULL)的检查
//因为当获得了实例之后，有了外层的判
//断之后，就不会再进入到内层判断，即
//不会再进行lock以及unlock的操作
singleton* singleton::initance()
{
    if (p == NULL)
    {
        // 加锁
        pthread_mutex_lock(&mutex);
        if (p == NULL)
            p = new singleton();
        pthread_mutex_unlock(&mutex);
    }
    return p;
}

2.饿汉：

#include <iostream>
#include <process.h>
#include <windows.h>
using namespace std;
 
class Singelton{
private:
    Singelton();
    static Singelton *single;
public:
    static Singelton *GetSingelton();
    
};


// 饿汉模式的关键：初始化即实例化
Singelton *Singelton::single = new Singelton;
 
Singelton *Singelton::GetSingelton(){
    // 不再需要进行实例化
    //if(single == nullptr){
    //    single = new Singelton;
    //}
    return single;
}