单例模式详解

一、什么是单例模式

1、定义
官方定义是这样的，单例模式是一种常用的软件设计模式，也叫单件模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。通俗点来说，就是一个类只允许实例化一个对象。

2、动机
对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务;一个系统只能有一个窗口管理器或文件系统;一个系统只能有一个计时工具或ID(序号)生成器。如在Windows中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源;如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要。

如何保证一个类只有一个实例并且这个实例易于被访问呢?定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。

3、实现要点：
1>单例类保证全局只有唯一一个自行创建的实例对象。
2.>单例类提供获取这个唯一实例的接口。

4、优缺点
优点：
1>实例控制
单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

2>灵活性
因为类控制了实例化过程，所以类可以灵活更改实例化过程。

缺点
1>开销
虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。

2>可能的开发混淆
使用单例对象(尤其在类库中定义的对象)时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。

3>对象生存期
不能解决删除单个对象的问题。在提供内存管理的语言中(例如基于.NET Framework的语言)，只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中(如 C++)，其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。

5、分类
单例的分类：懒汉模式（lazy load）、饿汉模式。
懒汉模式:只有当调用对象是才创建对象–相对而言，复杂—-但适用性高，各种场景下都适用。
饿汉模式：在函数一开始就创建（main）–简单高效，但是在某些场景下有缺陷—-适用性会受到限制，动态库。

二、懒汉模式的模拟实现（灰常重要）

实现方式一：普通写法

class Singleton
{
public:
    static Singleton* GetInstance()//获取唯一对象实例的接口函数
    {
        if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例
        {
            _inst = new Singleton;
        }
        return _inst;//返回实例化的唯一对象
    }
    void Print()
    {
        cout << "Singleton:" << _a << endl;
    }
private:
    Singleton()//将构造函数设为私有的，防止在外部创建实例
        :_a(0)
    {}

    int _a;
    static Singleton* _inst;//指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例 
};

Singleton* Singleton::_inst = NULL;//给静态成员指针初始化

void TestLazy()
{
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
}

运行结果：

由打印结果可知，我们设计的类确实只实例化出了一个对象，观察代码，我们发现虽然构造函数已经设置为私有的了，不能创建新的对象，但是我们仍然可以调用该类的拷贝构造函数和赋值运算符重载来创建其他对象，说到此处，我们就不得不对拷贝构造和赋值运算符重载也进行设定。

改进：类似实现一个防拷贝的类

class Singleton
{
   
public:
    static Singleton* GetInstance()//获取唯一对象实例的接口函数
    {
        if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例
        {
            _inst = new Singleton;
        }
        return _inst;//返回实例化的唯一对象
    }
    void Print()
    {
        cout << "Singleton:" <<_inst<< endl;
    }
private:
    Singleton()//将构造函数设为私有的，防止在外部创建实例
    {}
    Singleton(const Singleton&);//将拷贝构造函数声明为私有的
    Singleton& operator=(const Singleton&);//将赋值运算符重载设置为私有的

    static Singleton* _inst;//指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例 
};

Singleton* Singleton::_inst = NULL;//给静态成员指针初始化

实现方式二：考虑线程安全的写法
上述实现代码虽然大体功能已经符合要求，但是考虑细节问题时，它还是有很多纰漏的。诸如：在获取对象时的判断语句NULL == _inst， 如果内存中有两个线程同时在执行这句代码，在看到_inst时，他们都认为指针为空，于是同时进入if语句创建实例，从而违背单例模式的要求。

#include<iostream>
using namespace std;

#include<mutex>
class Singleton
{
   
public:
    static Singleton* GetInstance()// 获取唯一对象实例的接口函数
    {
        _mtx.lock();//加锁，加锁期间其余线程不能访问该临界区
        if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例
        {
            _inst = new Singleton;
        }
        _mtx.unlock();//解锁

        return _inst;//返回实例化的唯一对象
    }
    void Print()
    {
        cout << "Singleton:" <<_inst<< endl;
    }
private:
    Singleton()//将构造函数设为私有的，防止在外部创建实例
    {}
    Singleton(const Singleton&);//将拷贝构造函数声明为私有的
    Singleton& operator=(const Singleton&);//将赋值运算符重载设置为私有的

    static Singleton* _inst;// 指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例 
    int _a; // 单例类里面的数据
    static mutex _mtx; // 保证线程安全的互斥锁
};

Singleton* Singleton::_inst = NULL;//给静态指针赋值
mutex Singleton::_mtx;//_mtx会调用mutex默认的无参构造函数，所以不用初始化

void TestLazy()
{