单例模式详解

来源：互联网发布：淘宝被投诉盗图没申诉编辑：程序博客网时间：2024/06/06 02:24

一、什么是单例模式

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(){    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();}

运行结果：
这里写图片描述

Bug:上述加锁行为确实解决了线程安全问题，但是同时却引入了另一个麻烦，当一个线程进入到if语句创建实例时，可能由于栈空间不够或者某种异常中断导致程序异常终止，但是加的锁并没有进行解锁操作，导致其他线程也无法创建单例对象，从而导致死锁。

实现方式三：利用RAII机制自己“造轮子”避免死锁
RAII：资源获取即初始化，相当于资源分配和初始化时原子操作，其中不会中断

#include<iostream>using namespace std;#include<mutex>class Lock{public:    Lock(mutex& mtx)        :_mtx(mtx)    {        _mtx.lock();    }    ~Lock()    {        _mtx.unlock();    }private:    Lock(const Lock&);//防止拷贝    Lock& operator=(const Lock&);//防止赋值    mutex& _mtx;};class Singleton{public:    static Singleton* GetInstance()// 获取唯一对象实例的接口函数    {        //_mtx.lock();//加锁，加锁期间其余线程不能访问该临界区        Lock lock(_mtx);//RAII机制        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(){    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();}

运行结果：
这里写图片描述

上述代码确实避免了死锁问题，但是有一点不足，那就是不够高效。
改进一：添加双检查机制

#include<mutex>class Lock{public:    Lock(mutex& mtx)        :_mtx(mtx)    {        _mtx.lock();    }    ~Lock()    {        _mtx.unlock();    }private:    Lock(const Lock&);//防止拷贝    Lock& operator=(const Lock&);//防止赋值    mutex& _mtx;};class Singleton{public:    static Singleton* GetInstance()// 获取唯一对象实例的接口函数    {        if (NULL == _inst)//双检查机制，只有创建实例的时候才进行加锁解锁来提高代码效率        {            //_mtx.lock();//加锁，加锁期间其余线程不能访问该临界区            Lock lock(_mtx);//RAII机制            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默认的无参构造函数，所以不用初始化

改进二：调用库里的函数来避免自己造轮子的开销

class Singleton{public:    static Singleton* GetInstance()// 获取唯一对象实例的接口函数    {        if (NULL == _inst)//双检查机制，只有创建实例的时候才进行加锁解锁来提高代码效率        {            //_mtx.lock();//加锁，加锁期间其余线程不能访问该临界区            //Lock lock(_mtx);//RAII机制            lock_guard<mutex>lock(_mtx);            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默认的无参构造函数，所以不用初始化

实现方式四：巧用内存栅栏系统函数再次优化
特点：内存栅栏之前的语句和内存栅栏之后的语句不能交换执行次序。

运行程序，在以下代码处下断点：

if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例{    _inst = new Singleton;}

查看汇编指令：
这里写图片描述

由图可知，_inst = new Singleton;语句底层是由多条汇编代码来完成执行的，当然也就不是原子操作了，那么各条汇编指令的执行顺序我们也就无从得知了，在目前还算比较智能的编译器中很有可能为了追求效率二而打乱它们的执行顺序，从而可能触发错误。如:

如：原本顺序：operator new开空间–>构造函数–>赋值
如果顺序打乱为:operator new开空间–>赋值–>构造函数
此种情况下引入的双检查机制就会导致对没有初始化的变量进行赋值，使用未初始化的很有可能导致程序崩溃，当然也有可能影响并不大，为了完美起见，我们还是对其进行处理。

#include<iostream>using namespace std;#include<mutex>#include<windows.h>//class Lock//{//public://  Lock(mutex& mtx)//      :_mtx(mtx)//  {//      _mtx.lock();//  }//  ~Lock()//  {//      _mtx.unlock();//  }//private://  Lock(const Lock&);//防止拷贝//  Lock& operator=(const Lock&);//防止赋值////  mutex& _mtx;//};class Singleton{public:    static Singleton* GetInstance()// 获取唯一对象实例的接口函数    {        if (NULL == _inst)//双检查机制，只有创建实例的时候才进行加锁解锁来提高代码效率        {            //_mtx.lock();//加锁，加锁期间其余线程不能访问该临界区            //Lock lock(_mtx);//RAII机制            lock_guard<mutex>lock(_mtx);            if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例            {                //_inst = new Singleton;                Singleton* tmp = new Singleton;                MemoryBarrier();//优化----内存栅栏，防止编译器对指令流水进行乱序优化                _inst = tmp;            }            //_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(){    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();}

运行结果：
这里写图片描述

实现方式五：实例销毁处理
代码写到这里，基本已经差不多了，但是有人会想既然实例是new出来的，那么我们为什么不用delete将其释放掉呢，难道不会内存泄漏么？结果是当然会的，为什么不析构单例的实例呢，是因为它本身是一个静态的全局实例，之所以只能定义唯一一个，肯定是用的次数比较多，如果刚释放完空间又来创建单例对象，肯定就不得不偿失了。反过来说，单例模式一共就一个实例，考虑其本质特性，不释放的话在单例模式下可能会更好一些，待系统使用完毕后自动回收资源也是一个不错的选择。

在实际项目中，特别是客户端开发，其实是不在乎这个实例的销毁的。因为，全局就这么一个变量，全局都要用，它的生命周期伴随着软件的生命周期，软件结束了，它也就自然而然的结束了，因为一个程序关闭之后，它会释放它占用的内存资源的，所以，也就没有所谓的内存泄漏了。但是，有以下情况，是必须需要进行实例销毁的：
1、在类中，有一些文件锁，文件句柄，数据库连接等等，这些随着程序的关闭而不会立即关闭的资源，必须要在程序关闭前，进行手动释放；
2、具有强迫症的程序员。

对于小编这种具有很强的强迫症患者来说当然也是必须析构以下的啦!

#include<iostream>using namespace std;#include<mutex>#include<windows.h>//class Lock//{//public://  Lock(mutex& mtx)//      :_mtx(mtx)//  {//      _mtx.lock();//  }//  ~Lock()//  {//      _mtx.unlock();//  }//private://  Lock(const Lock&);//防止拷贝//  Lock& operator=(const Lock&);//防止赋值////  mutex& _mtx;//};class Singleton{public:    static Singleton* GetInstance()// 获取唯一对象实例的接口函数    {        if (NULL == _inst)//双检查机制，只有创建实例的时候才进行加锁解锁来提高代码效率        {            //_mtx.lock();//加锁，加锁期间其余线程不能访问该临界区            //Lock lock(_mtx);//RAII机制            lock_guard<mutex>lock(_mtx);            if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例            {                //_inst = new Singleton;                Singleton* tmp = new Singleton;                MemoryBarrier();//优化----内存栅栏，防止编译器对指令流水进行乱序优化                _inst = tmp;            }            //_mtx.unlock();//解锁        }        return _inst;//返回实例化的唯一对象    }    void Print()    {        cout << "Singleton:" <<_inst<< endl;    }    static void DellInstance()//在某些情况才需要释放    {        lock_guard<mutex> lock(_mtx);//防止对象被释放多次        if (_inst)        {            cout << "delete" << endl;            delete _inst;            _inst = NULL;//防止野指针的出现        }    }private:    Singleton()//将构造函数设为私有的，防止在外部创建实例    {}    Singleton(const Singleton&);//将拷贝构造函数声明为私有的    Singleton& operator=(const Singleton&);//将赋值运算符重载设置为私有的    ~Singleton()    {        //关闭文件锁，文件句柄，数据库连接等    }    static Singleton* _inst;// 指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例     int _a; // 单例类里面的数据    static mutex _mtx; // 保证线程安全的互斥锁};Singleton* Singleton::_inst = NULL;//给静态指针赋值mutex Singleton::_mtx;//_mtx会调用mutex默认的无参构造函数，所以不用初始化void TestLazy(){    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    Singleton::DellInstance();}

运行结果：
这里写图片描述

在上述情况中，我们还是没管住自己的小爪爪将单例对象释放掉了，但是如果我们在释放完之后又想调用该怎么办呢？
比如这样：

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

如此下来我们岂不是释放过早了，而且在饿汉模式下还可能会崩溃！！！

思来想去，我们知道main函数是所有线程的主线程，在它调用完成之后其他线程绝对早已退出，那么我们如果在主线程调用结束之后在对单例对象进行释放，那么绝逼是不会有任何问题的，接下来就是该想想如何实现了。
第一种释放：atexit

void TestLazy(){    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    //Singleton::DellInstance();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    atexit(Singleton::DellInstance);//注册回调函数，在main函数之后调用析构}

第二种释放：类中类

#include<iostream>using namespace std;#include<mutex>#include<windows.h>//class Lock//{//public://  Lock(mutex& mtx)//      :_mtx(mtx)//  {//      _mtx.lock();//  }//  ~Lock()//  {//      _mtx.unlock();//  }//private://  Lock(const Lock&);//防止拷贝//  Lock& operator=(const Lock&);//防止赋值////  mutex& _mtx;//};class Singleton{public:    static Singleton* GetInstance()// 获取唯一对象实例的接口函数    {        if (NULL == _inst)//双检查机制，只有创建实例的时候才进行加锁解锁来提高代码效率        {            //_mtx.lock();//加锁，加锁期间其余线程不能访问该临界区            //Lock lock(_mtx);//RAII机制            lock_guard<mutex>lock(_mtx);            if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例            {                //_inst = new Singleton;                Singleton* tmp = new Singleton;                MemoryBarrier();//优化----内存栅栏，防止编译器对指令流水进行乱序优化                _inst = tmp;            }            //_mtx.unlock();//解锁        }        return _inst;//返回实例化的唯一对象    }    void Print()    {        cout << "Singleton:" <<_inst<< endl;    }    static void DellInstance()//在某些情况才需要释放    {        lock_guard<mutex> lock(_mtx);//防止对象被释放多次        if (_inst)        {            cout << "delete" << endl;            delete _inst;            _inst = NULL;//防止野指针的出现        }    }    struct GC//实现方式二：类中类    {        ~GC()        {            DellInstance();//调用析构函数        }    };private:    Singleton()//将构造函数设为私有的，防止在外部创建实例    {}    Singleton(const Singleton&);//将拷贝构造函数声明为私有的    Singleton& operator=(const Singleton&);//将赋值运算符重载设置为私有的    ~Singleton()    {        //关闭文件锁，文件句柄，数据库连接等    }    static Singleton* _inst;// 指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例     int _a; // 单例类里面的数据    static mutex _mtx; // 保证线程安全的互斥锁};Singleton* Singleton::_inst = NULL;//给静态指针赋值mutex Singleton::_mtx;//_mtx会调用mutex默认的无参构造函数，所以不用初始化void TestLazy(){    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    //Singleton::DellInstance();    Singleton::GetInstance()->Print();    Singleton::GetInstance()->Print();    //atexit(Singleton::DellInstance);//注册回调函数，在main函数之后调用析构}static Singleton::GC gc;

三、饿汉模式的模拟实现

饿汉模式–简洁、高效、不用加锁、但是在某些场景下会有缺陷
实现方式一：

#include<iostream>using namespace std;#include<cassert>class Singleton    {    public:        static Singleton& GetInstance()        {            assert(_inst);            return *_inst;        }        void Print()        {            cout << "Singleton:" << _a << endl;        }    protected:        Singleton()            :_a(0)        {}        Singleton(const Singleton&);        Singleton& operator=(const Singleton&);        static Singleton* _inst;        int _a;    };    Singleton* Singleton::_inst = new Singleton;//静态成员在main函数之前初始化    void Test()    {        Singleton::GetInstance().GetInstance().Print();        Singleton::GetInstance().GetInstance().Print();        Singleton::GetInstance().GetInstance().Print();    }

运行结果：
这里写图片描述

实现方式二：

class Singleton1    {        public:            static Singleton1& GetInstance()            {                static Singleton1 inst;//静态变量只会创建一次                return inst;            }            void Print()            {                cout << "Singleton1:" << _a << endl;            }        protected:            Singleton1()                :_a(0)            {}            Singleton1(const Singleton1&);            Singleton1& operator=(const Singleton1&);            int _a;        };        void Test1()        {            Singleton1::GetInstance().GetInstance().Print();            Singleton1::GetInstance().GetInstance().Print();            Singleton1::GetInstance().GetInstance().Print();        }

[Now is 1:30,fighting!!!]

阅读全文

2 0