创建型模式 | 单例模式

MessiGo2023-12-22 19:42

一、单例模式

单例模式(Singleton Pattern)，使用最广泛的设计模式之一。其意图是保证一个类仅有一个实例被构造，并提供一个访问它的全局访问接口，该实例被程序的所有模块共享。

1、饿汉式

1.1、基础版本

在程序启动后立刻构造单例，饿汉式实现一个单例类步骤如下：

  • 定义一个单例类
  • 私有化构造函数，防止外界直接创建单例类的对象
  • 禁用拷贝构造，移动赋值等函数，可以私有化，也可以直接使用=delete
  • 使用一个公有的静态方法获取该实例
  • 确保在第一次调用之前该实例被构造

代码实现

cpp 复制代码 
#include <iostream>
#include <string>
using namespace std;

// 单例类
class Singleton {
protected:
    Singleton() { std::cout << "Singleton: call Constructor\n"; };

    static Singleton *m_pInst;

public:
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;

    virtual ~Singleton() { std::cout << "Singleton: call Destructor\n"; }

    static Singleton* GetInstance() {
        return m_pInst;
    }
};

Singleton *Singleton::m_pInst = new Singleton;

int main()
{
    Singleton *pInst1 = Singleton::GetInstance();
    Singleton *pInst2 = Singleton::GetInstance();

    cout << "pInst1 : " << pInst1 << endl;
    cout << "pInst2 : " << pInst2 << endl;

    return 0;
}

输出结果

cpp 复制代码 
Singleton: call Constructor
pInst1 : 0xf71760
pInst2 : 0xf71760

Process returned 0 (0x0)   execution time : 0.203 s
Press any key to continue.

从输出结果可以看出来，在执行main函数之前，单例类对象已经被创建出来。获取实例的函数也不需要进行判空操作，因此也就不用双重检测锁来保证线程安全了，它本身已经是线程安全状态了，但是内存泄漏的问题还是要解决的。

1.2、基于资源管理的饿汉实现

内存泄漏解决方法有两个：智能指针&静态嵌套类。

1.2.1、智能指针解决方案

将实例指针更换为智能指针，另外智能指针在初始化时，还需要添加公有的销毁函数，因为析构函数私有化了。

cpp 复制代码 
#include <iostream>
#include <string>
#include <mutex>
#include <memory>
#include <thread>
using namespace std;

// 单例类
class Singleton {
protected:
    Singleton() { std::cout << "Singleton: call Constructor\n"; };

    static shared_ptr<Singleton> instance;

private:
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;

    virtual ~Singleton() { std::cout << "Singleton: call Destructor\n"; }

public:
    // 自定义销毁实例方法
    static void DestoryInstance(Singleton* x) {
        delete x;
    }

    static shared_ptr<Singleton> GetInstance() {
        return instance;
    }
};

// 初始化
shared_ptr<Singleton> Singleton::instance(new Singleton(), DestoryInstance);

int main()
{
    cout << "main开始" << endl;

    thread t1([] {
        shared_ptr<Singleton> s1 = Singleton::GetInstance();
    });

    thread t2([] {
        shared_ptr<Singleton> s2 = Singleton::GetInstance();
    });

    t1.join();
    t2.join();

    cout << "main结束" << endl;

    return 0;
}

输出结果

cpp 复制代码 
Singleton: call Constructor
main开始
main结束
Singleton: call Destructor

Process returned 0 (0x0)   execution time : 0.116 s
Press any key to continue.

从输出结果可以看出来实例内存在程序运行结束后被正常释放。

1.2.2、静态嵌套类解决方案

类中定义一个嵌套类，初始化该类的静态对象，当程序结束时，该对象进行析构的同时，将单例实例也删除了。

cpp 复制代码 
#include <iostream>
#include <string>
#include <mutex>
#include <memory>
#include <thread>
using namespace std;

// 单例类
class Singleton {
    // 定义一个删除器（嵌套类）
    class Deleter {
        public:
            Deleter() {};
            ~Deleter() {
                if (m_pInst != nullptr) {
                    cout << "删除器启动" << endl;
                    delete m_pInst;
                    m_pInst = nullptr;
                }
            }
    };

protected:
    Singleton() { std::cout << "Singleton: call Constructor\n"; };

    static Deleter m_deleter;
    static Singleton* m_pInst;

private:
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;

    virtual ~Singleton() { std::cout << "Singleton: call Destructor\n"; }

public:
    static Singleton* GetInstance() {
        return m_pInst;
    }
};

Singleton *Singleton::m_pInst = new Singleton;
Singleton::Deleter Singleton::m_deleter;

int main()
{
    cout << "main开始" << endl;

    thread t1([] {
        Singleton *pInst1 = Singleton::GetInstance();
    });

    thread t2([] {
        Singleton *pInst2 = Singleton::GetInstance();
    });

    t1.join();
    t2.join();

    cout << "main结束" << endl;

    return 0;
}

输出结果

cpp 复制代码 
Singleton: call Constructor
main开始
main结束
删除器启动
Singleton: call Destructor

Process returned 0 (0x0)   execution time : 0.254 s
Press any key to continue.

从输出结果可以看出来单例类对象在程序运行结束时正常被释放。

2、懒汉式

2.1、基础版本

在使用类对象（单例实例）时才会去创建，实现如下：

cpp 复制代码 
#include <iostream>
#include <string>
#include <mutex>
#include <memory>
#include <thread>
using namespace std;

// 单例类
class Singleton
{
public:
    static Singleton* GetInstance() {
        if (m_pInst == nullptr) {
            m_pInst = new Singleton;
        }
        return m_pInst;
    }

private:
    // 私有构造函数
    Singleton() { cout << "构造函数启动。" << endl; };

    // 私有析构函数
    ~Singleton() { cout << "析构函数启动。" << endl; };

private:
    static Singleton* m_pInst;
};

// 初始化
Singleton* Singleton::m_pInst = nullptr;

int main()
{
    cout << "main开始" << endl;

    thread t1([] {
        Singleton *pInst1 = Singleton::GetInstance();
    });

    thread t2([] {
        Singleton *pInst2 = Singleton::GetInstance();
    });

    t1.join();
    t2.join();

    cout << "main结束" << endl;

    return 0;
}

上面的懒汉式存在两方面问题，一是：多线程场景存在并发问题；二是：创建的单例对象在使用完成后不会被释放存在资源泄露问题。

2.2、双重检查

使用双重检查解决多线程并发问题，核心代码如下：

cpp 复制代码 
static Singleton* GetInstance() {
    if (m_pInst == nullptr) {
        // 双重检查
        lock_guard<mutex> l(m_mutex);
        if (m_pInst == nullptr) {
            m_pInst = new Singleton();
        }
    }
    return m_pInst;
}

双重检查能解决多线程并发问题，同时效率也比单检查要高，调用GetInstance时只有当单例对象没有被创建时才会加锁，下面是单检查的实现，通过对比即可发现双检查的优点，如下：

cpp 复制代码 
static Singleton* GetInstance() {
    lock_guard<mutex> l(m_mutex);
    if (m_pInst == nullptr) {
        m_pInst = new Singleton();
    }

    return m_pInst;
}

2.3、基于静态局部对象的实现

C++11后，规定了局部静态对象在多线程场景下的初始化行为，只有在首次访问时才会创建实例，后续不再创建而是获取。若未创建成功，其他的线程在进行到这步时会自动等待。注意：C++11前的版本不是这样的。因为有上述的改动，所以出现了一种更简洁方便优雅的实现方法，基于局部静态对象实现，如下：

cpp 复制代码 
#include <iostream>
#include <string>
#include <mutex>
#include <memory>
#include <thread>
using namespace std;

// 单例类
class Singleton
{
public:
    static Singleton* GetInstance() {
        static Singleton instance;
        return &instance;
    }

private:
    // 私有构造函数
    Singleton() { cout << "构造函数启动。" << endl; };

    // 私有析构函数
    ~Singleton() { cout << "析构函数启动。" << endl; };
};

int main()
{
    cout << "main开始" << endl;

    thread t1([] {
        Singleton *pInst1 = Singleton::GetInstance();
    });

    thread t2([] {
        Singleton *pInst2 = Singleton::GetInstance();
    });

    t1.join();
    t2.join();

    cout << "main结束" << endl;

    return 0;
}
相关推荐
程序员Aries3 天前
从零开始实现一个高并发内存池_DayThree：内存池整体框架与ThreadCache、TLS无锁访问
c++·学习·单例模式
爱奥尼欧3 天前
【Linux】系统部分——线程安全与线程的单例模式
linux·安全·单例模式
青草地溪水旁3 天前
第一章：单例模式 - 武林中的孤高剑客
单例模式
huangyuchi.4 天前
【Linux实战 】Linux 线程池的设计、实现与单例模式应用
linux·c++·单例模式·线程池·懒汉模式·项目·linux系统
拧之5 天前
✅设计模式笔记
笔记·单例模式·设计模式
蓝莓味的口香糖6 天前
【JS】什么是单例模式
开发语言·javascript·单例模式
稚辉君.MCA_P8_Java10 天前
DeepSeek Java 单例模式详解
java·spring boot·微服务·单例模式·kubernetes
坐不住的爱码10 天前
单例模式入门
单例模式
CoderIsArt10 天前
四种对象型创建模式：抽象工厂、 build模式、原型ProtoType与单例模式
单例模式·原型模式
charlie11451419112 天前
精读C++20设计模式——创造型设计模式：单例模式
c++·学习·单例模式·设计模式·c++20
热门推荐
01两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答02GitHub 镜像站点03UV安装并设置国内源0446个Nano-banana 精选提示词，持续更新中05智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践06Cursor Plan Mode：AI 终于知道先想后做了07Linux下V2Ray安装配置指南08GitLab 零基础入门指南：从安装到项目管理全流程09一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示10jdk21下载、安装（Windows、Linux、macOS）