设计模式之单例模式

参考： 设计模式笔记

对于一个类A而言，整个系统中只能有一个该类的对象实例。比如，window的资源管理器，整个系统只有一个，每次打开的都是唯一的一个；一个班级只有一个班主任；一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

单例模式优缺点与适用场景

优点

1. 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2. 避免对资源的多重占用

缺点

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

适用场景

1. 要求生产唯一序列号。
2. WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3. 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

单例模式实现步骤

1. 构造函数私有化
2. 增加静态私有的当前类的指针
3. 提供静态的对外接口，可以让用户获取单例对象

原理

静态方法只能访问静态成员，而只有静态成员可以在没有创建对象的时候进行初始化，而且类的静态成员在第一次被初始化之后就不会再被初始化了，保证单例。

饿汉式创建（线程安全）

静态私有的当前类的指针，在类外直接完成类的初始化，这个初始化是在main函数之前执行的。

#include<iostream>
using namespace std;
class Singleton_hungry{
private:
    Singleton_hungry(){cout<<"hungry"<<endl;}
    static Singleton_hungry*instance;
public:
    static Singleton_hungry*getInstance(){
        return instance;
    }
};

//先于main进行初始化构造
Singleton_hungry*Singleton_hungry::instance=new Singleton_hungry();
int main(){
    cout<<"main"<<endl;
    Singleton_hungry*instance=Singleton_hungry::getInstance();
    return 0;
}

hungry
main

懒汉式创建

静态私有的当前类的指针，在需要用的时候才会创建。

#include<iostream>
using namespace std;
class Singleton_lazy{
private:
    Singleton_lazy(){cout<<"lazy"<<endl;}
    static Singleton_lazy*instance;
public:
    static Singleton_lazy*getInstance(){
        if(instance==nullptr) instance=new Singleton_lazy();
         return instance;
    }
   
};

//先于main进行初始化构造
Singleton_lazy*Singleton_lazy::instance=NULL;
int main(){
    cout<<"main"<<endl;
    Singleton_lazy*instance=Singleton_lazy::getInstance();
    return 0;
}

main
lazy

为什么懒汉式创建是线程不安全的？

假设开始线程0进入，判断instance为空，在将要创建实例时，cpu切换；线程1又进来了，同样instance为空，创建了实例，这时cpu切换回来到0线程，继续创建实例。

这样就创建了两个实例！就不再是单例模式了。

如何使得懒汉模式线程安全？

双重锁

单例对象释放

程序结束的时候，系统自动回收当前程序所有内存，一般不需要手动释放。