【重走编程路】设计模式概述（三） -- 单例模式

文章目录

• 前言
• 设计模式详解
• • 3.单例模式（Singleton）
  • • 问题
    • 解决方案
    • 应用场景
    • 实现代码
    • • 1. 懒汉式单例模式
      • 2. 加锁的懒汉式单例模式
      • 3. 饿汉式单例模式
      • 4. 静态内部变量(c++11)
      • 5. call_once实现懒汉单例

前言

创建型模式主要关注对象的创建过程，提供了一种创建对象的最佳方式，并隐藏了创建逻辑的细节。本章介绍创建型模式中的单例模式。

设计模式详解

3.单例模式（Singleton）

问题

在某些情况下，需要确保一个类只有一个实例，并且需要一个全局访问点来访问这个实例。例如，在一个应用程序中，一个配置管理器类需要保持一致的配置数据，以避免不同部分之间的配置冲突。

解决方案

单例模式特点是只提供唯一一个类的实例，它具有全局变量的特点，可以保证为一个类只生成唯一的实例对象（因为构造函数被私有化了，外部无法创建新的对象），在任何位置都可以通过接口获取到那个唯一实例对象。

应用场景

在应用系统开发中，我们常常有以下需求：
1.需要生成唯一序列的环境
2.需要频繁实例化然后销毁的对象。
3.创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
4.方便资源相互通信的环境
例如：多线程中网络资源初始化，回收站机制，任务管理器，应用程序日志管理…

实现代码

1. 懒汉式单例模式

适用于访问量较小，或实例较大的情况。

//懒汉式
#include <iostream>
using namespace std;
class SingleTon {
private:
    SingleTon();
    //禁用拷贝构造和赋值重载
    Singleton(const Singleton&) = delete;//C++11中，定义成员函数，可在后面使用 = delete修饰，表示该函数被删除，禁用；
    Singleton& operator=(const Singleton&) = delete;
public:
    static SingleTon* m_singleTon;
    static SingleTon* GetInstance();
    void TestPrint();
};
//懒汉式并不直接创建单例对象
SingleTon* SingleTon::m_singleTon = NULL;       
SingleTon::SingleTon() {
    m_singleTon = NULL;
    cout << "是我！" << endl;
}
SingleTon* SingleTon::GetInstance() {
    if (m_singleTon == NULL) {
        m_singleTon = new SingleTon;
    }
    else {
        cout << "还是我！" << endl;
    }
    return m_singleTon;
}
void SingleTon::TestPrint(){
    cout << "还是我！" << endl;
}
int main() {
    SingleTon* p1 = SingleTon::GetInstance();
    SingleTon* p2 = SingleTon::GetInstance();
    cout << "p1:" << hex << p1 << endl;
    cout << "p2:" << hex << p2 << endl;
    p1->TestPrint();
    p2->TestPrint();
    return 0;
}

运行结果

懒汉式线程不安全： 如果线程a和b同时调用GetInstance方法，在线程a创建对象还没修改m_singleTon变量时，线程b判断m_singleTon为空，也会走到创建对象的代码中，最后导致其中一个对象被覆盖。

为了保证线程安全，单例模式有了以下的写法：

2. 加锁的懒汉式单例模式

使用线程锁保证线程安全。

//加锁的懒汉式
#include <iostream>
#include <mutex>
using namespace std;
class Singleton {
public:
    static Singleton*& GetInstance();
    void Print() {
        std::cout << "我的实例内存地址是:" << this << std::endl;
    }

private:
    Singleton() {
        std::cout << "构造函数" << std::endl;
    }
    Singleton(const Singleton& signal);
    const Singleton& operator=(const Singleton& signal);

private:
    static Singleton* m_SingleInstance;
    static std::mutex m_Mutex;
};

//初始化静态成员变量
Singleton* Singleton::m_SingleInstance = NULL;
std::mutex Singleton::m_Mutex;

Singleton*& Singleton::GetInstance() {
    //  这里使用了两个 if判断语句的技术称为双检锁；好处是，只有判断指针为空的时候才加锁，
    //  避免每次调用 GetInstance的方法都加锁，锁的开销毕竟还是有点大的。
    if (m_SingleInstance == NULL) {
        std::unique_lock<std::mutex> lock(m_Mutex); // 加锁
        if (m_SingleInstance == NULL) {
            m_SingleInstance = new (std::nothrow) Singleton;
        }
    }
    return m_SingleInstance;
}

int main() {
    Singleton* p1 = Singleton::GetInstance();
    p1->Print();
    Singleton* p2 = Singleton::GetInstance();
    p2->Print();
    Singleton* p3 = Singleton::GetInstance();
    p3->Print();
    return 0;
}

3. 饿汉式单例模式

在程序运行前就完成单例的初始化，天生不存在线程问题。但是提前初始化单例，如果实例较大，会导致程序启动较慢；如果很久都用不上，实例还是会一直存在，占用大量的空间。适用于访问量较大或线程较多的情况。

//饿汉式
#include <iostream>
using namespace std;
class Singleton {
public:
    static Singleton* GetInstance() {
        return &instance;
    }
    void Print() {
        cout << m_num << endl;
    }
    int m_num;
private:
    Singleton(int num) {    //1.构造函数私有化
        m_num = num;
        cout << "是我" << endl;
    }
    static Singleton instance;  //2.定义一个唯一的类的实例对象
};
// 它是类内的成员，所以能访问私有构造函数，此时调用构造函数
Singleton Singleton::instance(2);// 类的静态成员变量要类外初始化,要写在main函数之前，保证程序运行时已经构造好了对象

int main() {
    Singleton* p1 = Singleton::GetInstance();
    p1->Print();
    Singleton* p2 = Singleton::GetInstance();
    p2->m_num = 5;
    Singleton* p3 = Singleton::GetInstance();
    p3->Print();
    return 0;
}

4. 静态内部变量(c++11)

使用静态内部变量实现懒汉式，使用c++11的特性，线程安全且代码量较少，推荐。

//静态内部变量实现的懒汉式
#include <iostream>
using namespace std;
class Singleton {
public:
    static Singleton& GetInstance() {
        static Singleton instance;
        return instance;
    }
    Singleton(Singleton const&) = delete;
    void operator=(Singleton const&) = delete;
    
    void Print() {
        cout << m_num << endl;
    }
    int m_num;
private:
    Singleton() {}
};

5. call_once实现懒汉单例

使用c++11的std::call_once实现的懒汉单例，call_once保证可调用对象_Fx只被执行一次，即使在多线程场景，函数原型：

template<class _Fn, class... _Args> inline
	void (call_once)(once_flag& _Flag, _Fn&& _Fx, _Args&&... _Ax)

其中：

• _Flag：标志对象，用于指示 _Fx 是否已调用过
• _Fx：可调用对象
• _Ax：传递的参数

//call_once实现懒汉单例
#include <iostream>
#include <memory>
#include <mutex>
class Singleton {
public:
    static std::shared_ptr<Singleton> GetSingleton();

    void Print() {
        std::cout << "Hello World." << std::endl;
    }

    ~Singleton() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }

private:
    Singleton() {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};

static std::shared_ptr<Singleton> singleton = nullptr;
static std::once_flag singletonFlag;

std::shared_ptr<Singleton> Singleton::GetSingleton() {
    std::call_once(singletonFlag, [&] {
        singleton = std::shared_ptr<Singleton>(new Singleton());
    });
    return singleton;
}
call_once方法代码的原文链接：
https://blog.csdn.net/unonoi/article/details/121138176

…

To be continued.