单例模式——懒汉模式
上一篇文章讲到了单例模式的饿汉模式，这一篇来讨论一下单例模式的懒汉模式。
所谓懒汉模式，就是像一个懒汉一样，需要用到创建实例了程序再去创建实例，不需要创建实例程序就“懒得”去创建实例，这是一种时间换空间的做法，这体现了“懒汉的本性”。
如果有多个线程，同时调用了获取实例，那么可能就会产生多个实例，那么这就不是我们的单例模式了。所以我们需要做一些事情才能保证我们是一个单例类。
额当然，我们先来考虑是单线程的情况，再去考虑多线程的情况，我们总得先把懒汉模式的本质给弄明白。
对于饿汉模式来说，它在单例类内部定义了一个类对象的指针，在初始化这个指针的时候，直接调用new在堆上申请了空间。于是达到了这种效果，在进入main函数之前，这个单例类的实例已经创建好了。
而对于懒汉模式而言，我们可不可以不让这个类对象指针在初始化的时候就new，而是给它赋一个NULL，那这样，在进入main函数之前，这个类对象指针只是一个空指针，并没有产生实际的对象。而当我们在程序中调用getInstance函数时，就需要进行一个判断，如果该类对象指针为空，那么我们就需要调用new创建一个对象，而如果该类对象指针不为空，那么我们就不用创建对象直接返回该指针就好了。根据这个思路，我们实现了下面的代码（因为我们的静态成员变量采用的是类对象的指针而不是类对象，因此我们需要写一个垃圾回收机制，这里我们采用的是上一篇文章的方法二，即实现一个内部的垃圾回收类）
singleton.hpp
#pragma once
#include
using namespace std;
class Singleton{
private:
Singleton(){
cout << "创建了一个单例对象" << endl;
}
Singleton(const Singleton&);
Singleton& operator=(const Singleton&);
~Singleton(){
// 析构函数我们也需要声明成private的
//因为我们想要这个实例在程序运行的整个过程中都存在
//所以我们不允许实例自己主动调用析构函数释放对象
cout << "销毁了一个单例对象" << endl;
}
static Singleton* instance; //这是我们的单例对象,它是一个类对象的指针
public:
static Singleton* getInstance();
private:
//定义一个内部类
class Garbo{
public:
Garbo(){}
~Garbo(){
if(instance != NULL){
delete instance;
instance = NULL;
}
}
};
//定义一个内部类的静态对象
//当该对象销毁的时候，调用析构函数顺便销毁我们的单例对象
static Garbo _garbo;
};
//下面这个静态成员变量在类加载的时候就已经初始化好了
Singleton* Singleton::instance = NULL;
Singleton::Garbo Singleton::_garbo; //还需要初始化一个垃圾清理的静态成员变量
Singleton* Singleton::getInstance(){
if(instance == NULL)
instance = new Singleton();
return instance;
}
test.cc
#include "singleton.hpp"
int main(){
cout << "Now we get the instance" << endl;
Singleton* instance1 = Singleton::getInstance();
Singleton* instance2 = Singleton::getInstance();
Singleton* instance3 = Singleton::getInstance();
cout << "Now we destroy the instance" << endl;
return 0;
}
程序的运行结果如下图
可以看到我们先进入了main函数中，在调用了第一个getInstance获取实例的时候才创建了一个单例对象。在调用后续的getInstance获取实例的时候因为instance不为空，所以直接返回instance。
当然了上面我们是在堆上创建了对象，想在栈上创建对象也是可以的
singleton.hpp
#pragma once
#include
using namespace std;
class Singleton{
private:
Singleton(){
cout << "创建了一个单例对象" << endl;
}
Singleton(const Singleton&);
Singleton& operator=(const Singleton&);
~Singleton(){
// 析构函数我们也需要声明成private的
//因为我们想要这个实例在程序运行的整个过程中都存在
//所以我们不允许实例自己主动调用析构函数释放对象
cout << "销毁了一个单例对象" << endl;
}
public:
static Singleton* getInstance();
};
Singleton* Singleton::getInstance(){
static Singleton instance;
return &instance;
}
test.cc
#include "singleton.hpp"
int main(){
cout << "Now we get the instance" << endl;
Singleton* instance1 = Singleton::getInstance();
Singleton* instance2 = Singleton::getInstance();
Singleton* instance3 = Singleton::getInstance();
cout << "Now we destroy the instance" << endl;
return 0;
}结果是一样的
上面这两种情况在单线程的情况下，是没有问题。但是试想在多线程的情况下，试想一下如果多个线程同时调用了getInstance函数，此时可能存在多线程竞态环境，就可能会产生重复构造或者是构造不完全等问题。因此我们在getInstance函数中还要采用线程同步的方式，保证线程同步，从而达到单例类的目的
singleton.hpp（在堆上创建对象）
#pragma once
#include
using namespace std;
class Singleton{
private:
Singleton(){
cout << "创建了一个单例对象" << endl;
}
Singleton(const Singleton&);
Singleton& operator=(const Singleton&);
~Singleton(){
// 析构函数我们也需要声明成private的
//因为我们想要这个实例在程序运行的整个过程中都存在
//所以我们不允许实例自己主动调用析构函数释放对象
cout << "销毁了一个单例对象" << endl;
}
static Singleton* instance; //这是我们的单例对象,它是一个类对象的指针
public:
static Singleton* getInstance();
private:
//定义一个内部类
class Garbo{
public:
Garbo(){}
~Garbo(){
if(instance != NULL){
delete instance;
instance = NULL;
}
}
};
//定义一个内部类的静态对象
//当该对象销毁的时候，调用析构函数顺便销毁我们的单例对象
static Garbo _garbo;
};
//下面这个静态成员变量在类加载的时候就已经初始化好了
Singleton* Singleton::instance = NULL;
Singleton::Garbo Singleton::_garbo; //还需要初始化一个垃圾清理的静态成员变量
Singleton* Singleton::getInstance(){
Lock(); // 加锁
if(instance == NULL)
instance = new Singleton();
UnLock(); // 解锁
return instance;
} singleton.hpp（在栈上创建对象）
#pragma once
#include
using namespace std;
class Singleton{
private:
Singleton(){
cout << "创建了一个单例对象" << endl;
}
Singleton(const Singleton&);
Singleton& operator=(const Singleton&);
~Singleton(){
// 析构函数我们也需要声明成private的
//因为我们想要这个实例在程序运行的整个过程中都存在
//所以我们不允许实例自己主动调用析构函数释放对象
cout << "销毁了一个单例对象" << endl;
}
public:
static Singleton* getInstance();
};
Singleton* Singleton::getInstance(){
Lock(); //加锁
static Singleton instance;
UnLock(); //解锁
return &instance;
}
其中，这些Lock()和UnLock()我并没有实现，这是一个加锁的步骤而已，都是常见的线程同步的方法，所以懂就好啦~~~
当两个线程同时想创建一个实例，由于在一个时刻只有一个线程能得到同步锁，当一个线程加上锁时，第二个线程只能等待，当第一个线程发现实例还没有创建时，它创建出第一个实例。接着第一个线程释放同步锁，此时第二个线程可以加上同步锁，这个时候由于实例已经被第一个线程创建出来了，第二个线程就不会重复创建了，这样就保证了我们在多线程环境中也只能得到一个实例。
但是问题就出来了，加锁和解锁的操作是需要时间的，因此在线程很多的情况下，就会浪费大量的时间，导致效率下降。下面我们可以用一种优化的方法（因为只改动了getInstance这个函数，于是我只把这个函数写了出来）。
Singleton* Singleton::getInstance(){
if(instance == NULL){
Lock(); // 加锁
if(instance == NULL)
instance = new Singleton();
UnLock(); // 解锁
}
return instance;
}上面这种方法只有在instance为空的时候才需要加锁和解锁操作，如果已经创建出来了实例，则无需加锁。所以上面的代码只有在第一个创建实例时才会需要加锁。这样的方法效率已经很好了，只是实现起来比较麻烦，容易出错。
到这里单例模式的懒汉和饿汉模式就都介绍完了，总结一下，懒汉和饿汉分别适用于什么场景。
- 懒汉模式适用于线程比较少的场景，因为线程一旦多，加锁的开销就会体现出来（当然最后对懒汉优化的那种方案已经差不多解决这个问题了），总之它是一种时间换空间的模式。
- 饿汉模式适用于线程比较多的场景，它会占用全局静态区一定的空间，但是能够确保只有一个实例。但是当线程很少，甚至是没有用到这个单例类的时候，就显得得不偿失了，它占用的空间问题就体现出来了，这是一种空间换时间的模式。