C++设计模式——单例模式

悠悠 2022-07-16 10:57 196阅读 0赞

何为单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点, 该实例被所有程序模块共享。  
首先，需要保证一个类只有一个实例；在类中，要构造一个实例，就必须调用类的构造函数，如此，为了防止在外部调用类的构造函数而构造实例，需要将构造函数的访问权限标记为private或者protected；最后，需要提供要给全局访问点，就需要在类中定义一个static函数，返回在类内部唯一构造的实例。

实现方法一：  
用户访问唯一实例的方法只有GetInstance()成员函数。如果不通过这个函数，任何创建实例的尝试都将失败，因为类的构造函数是私有的。GetInstance()使用懒惰初始化，也就是说它的返回值是当这个函数首次被访问时被创建的。这是一种防弹设计——所有GetInstance()之后的调用都返回相同实例的指针：

#include <iostream>
    using namespace std;
    
    class Singleton
    {
    public:
        static Singleton *GetInstance()
        {
            if (m_Instance == NULL )
            {
                m_Instance = new Singleton ();
            }
            return m_Instance;
        }
    
        static void DestoryInstance()
        {
            if (m_Instance != NULL )
            {
                delete m_Instance;
                m_Instance = NULL ;
            }
        }
         // This is just a operation example
        int GetTest()
        {
            return m_Test;
        }
    
    private:
        Singleton(){ m_Test = 10; }
        static Singleton *m_Instance;
        int m_Test;
    };
    
    Singleton *Singleton ::m_Instance = NULL;
    
    int main(int argc , char *argv [])
    {
        Singleton *singletonObj = Singleton ::GetInstance();
        cout<<singletonObj->GetTest()<<endl;
    
        Singleton ::DestoryInstance();
        return 0;
    }

这样就可以了，保证只取得了一个实例。但是在多线程的环境下却不行了，因为很可能两个线程同时运行到if (instance == NULL)这一句，导致可能会产生两个实例。于是就要在代码中加锁。

Singleton* getInstance()
    {
        lock();
        if (instance == NULL)
        {
     instance = new Singleton(); } unlock(); return instance; }

但这样写的话，会稍稍影响性能，因为每次判断是否为空都需要被锁定，如果有很多线程的话，就可能会造成大量线程的阻塞。于是大神们又想出了双重锁定。

Singleton* getInstance()
    {
        if (instance == NULL)
        {
            lock();
            if (instance == NULL)
            {
     instance = new Singleton(); } unlock(); } return instance; }

这样只够极低的几率下，通过越过了if (instance == NULL)的线程才会有进入锁定临界区的可能性，这种几率还是比较低的，不会阻塞太多的线程，但为了防止一个线程进入临界区创建实例，另外的线程也进去临界区创建实例，又加上了一道防御if (instance == NULL)，这样就确保不会重复创建了。

实现方法二：  
改进资源回收的问题，实例自动销毁

#include <iostream>
    using namespace std;
    
    
    class Singleton
    {
    public:
        static Singleton* GetInstance()
        {
            if(m_Instance == NULL)  //判断是否第一次调用
                m_Instance = new Singleton();
            return m_Instance;
        }
    
    
    private:
        Singleton(){ }
        static Singleton *m_Instance;
    
    
        // This is important
        class GC
        {
        public:
            ~GC()
            {
                if (m_Instance != NULL)
                {
                    cout << "Here is the test" << endl;
                    delete m_Instance;
                    m_Instance = NULL;
                }
            }
        };
        static GC gc;
    };
    
    
    Singleton *Singleton::m_Instance = new Singleton();
    Singleton::GC Singleton::gc;
    
    
    int main(int argc, char *argv[])
    {
        Singleton *singletonObj = Singleton::GetInstance();
    
    
        return 0;
    }

由于程序在结束的时候，系统会自动析构所有的全局变量，实际上，系统也会析构所有类的静态成员变量，就像这些静态变量是全局变量一样。我们知道，静态变量和全局变量在内存中，都是存储在静态存储区的，所以在析构时，是同等对待的。 在程序运行结束时，系统会调用Singleton的静态成员GC的析构函数，该析构函数会进行资源的释放，而这种资源的释放方式是在程序员“不知道”的情况下进行的，而程序员不用特别的去关心，使用单例模式的代码时，不必关心资源的释放。