C++11标准下的单例设计模式

素颜马尾好姑娘i 2022-10-18 11:25 100阅读 0赞

# 单例设计模式 #

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

### 为什么会产生设计模式这样的东西呢？ ###

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

其中最具代表性的就是单例设计模式

### 单例设计模式 ###

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

在linux下曾提到过单例设计模式：

实现：

*  饿汉模式：资源在程序初始化阶段就完成加载（空间换时间）
 *  饿汉方法实现：

1.  采用静态方法修饰资源，所有对象共用同一份资源，程序初始化阶段完成资源加载且只被加载一次
2.  构造函数私有化 ，保证一个类只能实例化一个对象

template <typename T>
    class Singleton {
        static T data;
        Singleton(){}//构造函数私有化
    public:
        static T* GetInstance() {
            return &data;
        }
    };

*  懒汉模式：资源在使用的时候再去加载（延迟加载）

1.  定义对象指针，初始资源为空
2.  static修饰，共用一份资源
3.  volatite修饰 ，防止编译器过度优化
4.  加锁保护 线程安全
5.  二次检测，防止锁冲突

template <typename T>
    class Singleton {
        volatite static T* inst;//定义对象指针  初始为空
        static std::mutex _mutex;
    public:
        static T* GetInstance() {
            if(inst==NULL)//double check 二次检测，避免不为空情况依然加锁，造成锁冲突
            {
                _mutex.lock();
                if (inst == NULL) {
                    inst = new T();//调用时发现为空，进行获取资源
                }
                _mutex.unlock();
            }
            return inst;
        }
    };

总结来说，单例设计主要分为两种：

*  饿汉模式（提前响应）
 *  懒汉模式（延迟加载）
 *  ### 饿汉模式 ###

在C++11标准下，饿汉模式要求：程序启动时就创建一个唯一的实例对象

要满足此条件，提前创建对象，只有将其定义为全局变量或静态变量，才会程序启动前完成创建

// 饿汉模式
    // 优点：简单
    // 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。
    class Singleton
    {
    public:
    static Singleton* GetInstance()
    {
    return &m_instance;
    }
    private:
    // 构造函数私有
    Singleton(){};
    
    // C++11防拷贝
    Singleton(Singleton const&) = delete;
    Singleton& operator=(Singleton const&) = delete;
    static Singleton m_instance;
    };
    Singleton Singleton::m_instance; // 在程序入口之前就完成单例对象的初始化

注：  
**1，构造函数私有 外部无法创建对象  
2，通过接口 指针获取已创建对象  
3，类内 定义静态成员对象，类外初始化**

**4，定义静态成员，静态成员定义在类内，类内可以访问私有成员函数完成构造，且静态成员存储在静态数据区，与类不为同一块存储空间**

*  ### 懒汉模式 ###

#include <iostream>
    #include <mutex>
    #include <thread>
    using namespace std;
    class Singleton
    {
    public:
        static Singleton* GetInstance() {
    // 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全
        if (nullptr == m_pInstance) {//第一次判断防止多次加锁导致锁冲突
            m_mtx.lock();
            if (nullptr == m_pInstance) {//第二次判断是否为空，为空则为第一次调用构造函数创建，不为空，后续都不会调用构造函数，满足对象第一次创建且仅创建一次
                m_pInstance = new Singleton();
            }
            m_mtx.unlock();
        }    
        return m_pInstance;
        }
        // 实现一个内嵌垃圾回收类
        class CGarbo {
        public:
            ~CGarbo(){
                if (Singleton::m_pInstance)
                    delete Singleton::m_pInstance;
            }
        };
    // 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
    static CGarbo Garbo;
    private:
        // 构造函数私有
        Singleton(){};
        // 防拷贝
        Singleton(Singleton const&);
        Singleton& operator=(Singleton const&);
        static Singleton* m_pInstance; // 单例对象指针 静态成员变量，在调用构造函数前先创建进行判断
        static mutex m_mtx; //互斥锁
    };
    Singleton* Singleton::m_pInstance = nullptr;//静态成员变量类外初始化，第一次初始化为nullptr
    Singleton::CGarbo Garbo;
    mutex Singleton::m_mtx;
    void func(int n)
    {
        cout<< Singleton::GetInstance() << endl;
    }
    
    // 多线程环境下演示上面GetInstance()加锁和不加锁的区别。
    int main()
    {
        thread t1(func, 10);
        thread t2(func, 10);
        t1.join();
        t2.join();
        cout << Singleton::GetInstance() << endl;
        cout << Singleton::GetInstance() << endl;
    }