【设计模式】单例模式代码设计

单例模式简介

单例模式指的是，无论怎么获取，永远只能得到该类类型的唯一一个实例对象，那么设计一个单例就必须要满足下面三个条件：

1、构造函数私有化，这样用户就不能任意定义该类型的对象了
2、定义该类型唯一的对象
3、通过一个static静态成员方法返回唯一的对象实例

饿汉单例模式

饿汉式单例模式，顾名思义，就是程序启动时就实例化了该对象，并没有推迟到第一次使用该对象时再进行实例化

为什么getInstance成员函数要加static关键字？因为普通成员方法的调用还是要依赖于对象，但现在没对象，现在是通过接口来获取对象的，所以返回唯一的对象实例的函数应该是静态成员函数。

下面这个是饿汉式单例模式：

#include <iostream>
using namespace std;
/*
单例模式：
饿汉式单例模式：还没有获取实例对象，实例对象就已经产生了
懒汉式单例模式：唯一的实例对象，直到第一次获取它的时候，才产生
*///饿汉式单例模式，一定是线程安全的
class Singleton
{
public:static Singleton* getInstance()//#3 获取类的唯一实例对象的接口方法{return &instance;}
private:static Singleton instance;//#2 定义一个唯一类的实例对象Singleton()     //#1 构造函数私有化{}Singleton(const Singleton &) = delete;Singleton &operator=(const Singleton&) = delete;
};Singleton Singleton::instance;int main()
{Singleton *p1 = Singleton::getInstance();Singleton *p2 = Singleton::getInstance();Singleton *p3 = Singleton::getInstance();cout << p1 << " " << p2 << " " << p3 << endl;return 0;
}

在这里插入图片描述

但有时呢，可能你整个任务过程中都没有试图获取过该单例对象，但函数是先于程序执行载入的，那么可能饿汉模式，先定义了一个唯一的实例对象，并且构造函数进行了大量的初始化，所以在程序启动时就会先创建出一个实例化对象，白白浪费很多时间。所以有时就会用懒汉模式

懒汉单例模式

下面这个是懒汉式单例模式，把对象的实例化延迟到第一次获取该实例对象时。在程序启动时，它仅仅先创建了一个指针而不是一个对象

可重入函数：在多线程中能够被不同线程重复调用，即一个线程调用还没结束时，另一个线程又来调用，这样的函数就称为可重入函数

#include <iostream>
using namespace std;/*
单例模式：
饿汉式单例模式：还没有获取实例对象，实例对象就已经产生了
懒汉式单例模式：唯一的实例对象，直到第一次获取它的时候，才产生
*///懒汉式单例模式，存在线程安全的问题
class Singleton
{
public:static Singleton* getInstance()//#3 获取类的唯一实例对象的接口方法{if(instance==nullptr){instance = new Singleton();}return instance;}
private:static Singleton *instance;//#2 定义一个唯一类的实例对象Singleton()     //#1 构造函数私有化{}Singleton(const Singleton &) = delete;Singleton &operator=(const Singleton&) = delete;
};Singleton* Singleton::instance=nullptr;int main()
{Singleton *p1 = Singleton::getInstance();Singleton *p2 = Singleton::getInstance();Singleton *p3 = Singleton::getInstance();cout << p1 << " " << p2 << " " << p3 << endl;return 0;
}

在这里插入图片描述

线程安全的懒汉单例模式

饿汉单例模式中，单例对象定义成了一个static静态对象，它是在程序启动时，main函数运行之前就初始化好的，因此不存在线程安全问题，可以放心的在多线程环境中使用。但上面的懒汉模式代码却不是安全的

在静态成员变量instance的前面加volatile关键字，是因为在多线程中cpu为了加快速度，往往会将静态成员变量的值都拷贝一份，带到各个的线程中去，放到cpu的缓存里。而加了volatile，加了该关键字后，就禁止了各个线程拷贝该变量。如果该静态成员变量的值发生改变，那么所有的线程都会立刻看到静态成员变量的改变

下面是线程安全的懒汉单例模式：

#include <iostream>
#include<mutex>
using namespace std;/*
单例模式：
饿汉式单例模式：还没有获取实例对象，实例对象就已经产生了
懒汉式单例模式：唯一的实例对象，直到第一次获取它的时候，才产生
*/mutex mtx;
//懒汉式单例模式=》是不是线程安全的呢？=》线程安全的懒汉式单例模式    
class Singleton
{
public://是不是可重入函数呢？  锁+双重判断static Singleton* getInstance()//#3 获取类的唯一实例对象的接口方法{//lock_guard<mutex> guard(mtx);//在这里加锁锁的粒度太大了，如果是单线程的话，调用该函数还是要每次加锁解锁if(instance==nullptr){lock_guard<mutex> guard(mtx);if(instance==nullptr){/*开辟函数构造函数私有化给instance赋值*/instance = new Singleton();}   }return instance;}
private:static Singleton *volatile instance;//#2 定义一个唯一类的实例对象Singleton()     //#1 构造函数私有化{}Singleton(const Singleton &) = delete;Singleton &operator=(const Singleton&) = delete;
};Singleton*volatile Singleton::instance=nullptr;int main()
{Singleton *p1 = Singleton::getInstance();Singleton *p2 = Singleton::getInstance();Singleton *p3 = Singleton::getInstance();cout << p1 << " " << p2 << " " << p3 << endl;return 0;
}

在这里插入图片描述

当然，线程安全的懒汉模式还有另一种写法，如下：

#include <iostream>
#include<mutex>
using namespace std;/*
单例模式：
饿汉式单例模式：还没有获取实例对象，实例对象就已经产生了
懒汉式单例模式：唯一的实例对象，直到第一次获取它的时候，才产生
*///懒汉式单例模式
class Singleton
{
public://仅在第一次调用该函数的时候，才会创建该对象static Singleton* getInstance()//#3 获取类的唯一实例对象的接口方法{//函数静态局部变量的初始化，在汇编指令上已经自动添加了线程互斥指令了static Singleton instance;return &instance;}
private:Singleton()     //#1 构造函数私有化{}Singleton(const Singleton &) = delete;Singleton &operator=(const Singleton&) = delete;
};int main()
{Singleton *p1 = Singleton::getInstance();Singleton *p2 = Singleton::getInstance();Singleton *p3 = Singleton::getInstance();cout << p1 << " " << p2 << " " << p3 << endl;return 0;
}