C++单例模式

已于 2024-10-10 18:26:23 修改
阅读量400 收藏 17
点赞数 10
文章标签： c++ webserver 设计模式
于 2024-10-10 15:01:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_35852648/article/details/141392116
版权

先简单介绍一下单例模式：

        单例模式（Singletion Pattern）是一种软件开发中的设计模式，属于创建型模式（也称工厂模式，封装对象的创建过程，使客户端可以透明地创建对象，而不需要关心对象的内部实现细节）。单例模式确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。单例模式通常用于管理共享资源，如数据库连接、文件系统、硬件设备等，或者在多个线程之间共享数据。

 由上面的定义，我们也可以知道单例模式的几个特点：

  1. 全局唯一性：确保一个类只有一个实例，并提供一个全局访问点。
  2. 自我实例化：单例类负责创建自己的唯一实例。
  3. 延迟初始化：单例实例通常在第一次使用时创建，而不是在程序启动时。
  4. 可访问性：单例类通常提供一个静态的访问方法，允许客户端访问其唯一实例。

实现单例模式需要以下几个步骤：

  • 私有构造函数：防止外部通过new直接创建类的实例。
  • 静态私有实例变量：保存类的唯一实例。
  • 静态公有方法：提供一个全局访问点用于获取唯一实例。

简单的单例模式（懒汉Lazy Singleton）

#include <iostream>

class Singleton{
private:
    //私有构造函数
    Singleton(){}
    //静态私有实例变量
    static Singleton* instance;
public:
    //禁止拷贝构造函数和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    //公有静态方法，提取全局访问点
    static Singleton* getInstance(){
        //判断是否第一次调用
        if(instance = nullptr){
            instance = new Singleton();
        }
        return instance;
    }
    //实例方法
    void dosomething(){
        std::cout<<"Hello world"<<std:;endl;
    }
}

// 初始化静态私有实例变量
Singleton * Singleton::instance = nullptr;

int main(){
    //获取单例实例
    Singleton* singleton = Singleton::getInstance();
    //使用单例实例
    singleton->dosomething();
}

        这个简单实例也称为懒汉单例模式（Lazy Singleton），单例在第一次使用才会被初始化，或称为延迟初始化，也正因为仅在第一次使用时创建单例实例，能够节省资源，但在某些情况下，可能会导致内存泄漏。举例如下：

  • 单例实例通常为静态成员变量，静态成员变量的生命周期与程序的生命周期相同，若单例实例持有资源（动态分配的内存、文件描述符等），而这些资源在程序运行期间未正确释放，会导致内存泄漏。
  • 单例实例是静态的，它的销毁通常需要在程序结束时通过显式的代码来完成。如果忘记编写这样的销毁代码，持有的资源不会释放。

这里提供一个会造成内存泄漏的例子

class Singleton {
private:
    static Singleton* instance;
    // 假设单例持有动态分配的内存
    int* data;

    Singleton() {
        data = new int[100]; // 动态分配内存
    }

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
    // 公有析构函数，虽然是公有的，但由于是私有的构造函数，外部无法创建实例
    ~Singleton() {
        delete[] data; // 释放动态分配的内存
    }
};

Singleton* Singleton::instance = nullptr;

int main() {
    // 使用单例
    Singleton* singleton = Singleton::getInstance();
    // 单例实例持有的动态分配的内存没有释放
    return 0;
}

Singleton持有一个指向动态分配数组的指针data，由于没有提供销毁单例实例的函数，当程序结束时，data指向的内存未被释放，从而导致内存泄漏。

针对这一问题，有以下两种解决方案：

1.使用智能指针

2.使用静态的嵌套类对象

智能指针

上述代码可以改为：

#include <memory> // 包含智能指针的头文件

class Singleton {
private:
    static std::unique_ptr<Singleton> instance; // 使用智能指针管理单例实例
    int* data;

    // 私有构造函数
    Singleton() {
        data = new int[100]; // 动态分配内存
    }

    // 禁止拷贝构造函数和赋值操作符
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:

    // 静态公有方法，提供全局访问点
    static Singleton* getInstance() {
        if (instance.get() == nullptr) {
            instance.reset(new Singleton()); // 使用智能指针管理单例实例
        }
        return instance.get();
    }
    // 公有析构函数，虽然是公有的，但由于是私有的构造函数，外部无法创建实例
    ~Singleton() {
        delete[] data; // 释放动态分配的内存
    }
};

// 初始化静态成员变量
std::unique_ptr<Singleton> Singleton::instance = nullptr;

int main() {
    // 使用单例
    Singleton* singleton = Singleton::getInstance();
    // 程序结束时，智能指针会自动释放单例实例，包括其持有的动态分配的内存
    return 0;
}

嵌套类

class Singleton {
private:
    static Singleton* instance; // 静态指针，用于存储单例的唯一实例
    int* data; // 指向动态分配内存的指针

    // 私有构造函数，只能内部调用
    Singleton() {
        data = new int[100]; // 动态分配内存
    }

    // 私有析构函数，只能内部调用
    ~Singleton() {
        delete[] data; // 释放动态分配的内存，防止内存泄漏
    }

    // 内部类，用于在程序结束时自动销毁单例实例
    class Deletor {
    public:
        // 析构函数，在程序结束时调用
        ~Deletor() {
            if (Singleton::instance != nullptr)
                delete Singleton::instance; // 如果单例实例存在，则删除它
        }
    };
    // 静态成员变量，用于确保Deletor的析构函数在程序结束时被调用
    static Deletor deletor;

public:
    // 静态公有方法，提供全局访问点，用于获取单例实例
    static Singleton* getInstance() {
        if (instance == nullptr) { // 如果单例实例尚未创建
            instance = new Singleton(); 
        }
        return instance;
    }
};

// 初始化静态成员变量
Singleton* Singleton::instance = nullptr; // 初始化为nullptr，表示单例实例尚未创建
Singleton::Deletor Singleton::deletor; // 创建Deletor实例，以便在程序结束时调用其析构函数

// 主函数
int main() {
    Singleton* singleton = Singleton::getInstance(); // 获取单例实例
    // 使用单例实例...
    return 0; // 程序结束，Deletor的析构函数将被调用，自动销毁单例实例
}

        在程序运行结束时，系统会调用静态成员deletor的析构函数，该析构函数会删除单例的唯一实例。用这种方法释放单例对象。

  • 在单例类内部定义专有的嵌套类。
  • 在单例类内定义私有的专门用于释放的静态成员
  • 利用程序在结束时析构全局变量的特性，选择最终的释放时机。

对于内存泄漏的检测，考虑使用valgrind

多线程下的单例模式

这些代码在单线程下环境是正确的，但是当处于多线程环境时，会发生竞争。最简单的解决竞争的方式是加入锁机制来保护临界区。

于是就有了最简单的多线程环境下的单例模式代码：

#include <iostream>

class Singleton{
private:
    //私有构造函数
    Singleton(){}
    //静态私有实例变量
    static Singleton* instance;
    mutex mutex;
public:
    //禁止拷贝构造函数和赋值操作
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    //公有静态方法，提取全局访问点
    static Singleton* getInstance(){
        //判断是否第一次调用
        //上锁    
        mutex.lock();
        if(instance = nullptr){
            instance = new Singleton();
        }
        //解锁
        mutex.unlock();
        return instance;
    }
    //实例方法
    void dosomething(){
        std::cout<<"Hello world"<<std:;endl;
    }
}

// 初始化静态私有实例变量
Singleton * Singleton::instance = nullptr;

int main(){
    //获取单例实例
    Singleton* singleton = Singleton::getInstance();
    //使用单例实例
    singleton->dosomething();
}

Double Checked Locking（DCL）

考虑到线程安全仅存在于第一次初始化（new）过程中，而在后续获取该实例时并不会遇到，也就没有必要再使用lock。使用双重检查锁定（Double-Checked Locking）来确保单例实例的线程安全，主要目的时减少加锁的次数。在细节上：

  1. 第一次检查：在getinstance方法中，首先检查instance是否为nullptr，若是，则继续执行、
  2. 加锁：使用std::lock_guard来确保mutex在作用域内被正确地加锁和解锁。这种方法被称为作用域锁，因为它在lock_guard对象的作用域结束时自动解锁。
  3. 第二次检查：在加锁前，再次检查instance是否为nullptr，若仍为nullptr，则加锁并创建单例实例。
  4. 创建实例：在加锁后，如果instance仍为nullptr，则创建实例。
  5. 返回实例：无论是否创建了新实例，最终都返回instance指针。
static Singleton* getInstance() {
    if (instance == nullptr) {
        std::lock_guard<std::mutex> lock(mutex); // 作用域锁
        if (instance == nullptr) {
            instance = new Singleton(); // 创建单例实例
        }
    }
    return instance;
}

“加入DCL后，其实还是有问题的，关于memory model。在某些内存模型中（虽然不常见）或者是由于编译器的优化以及运行时优化等等原因，使得instance虽然已经不是nullptr但是其所指对象还没有完成构造，这种情况下，另一个线程如果调用getInstance()就有可能使用到一个不完全初始化的对象。换句话说，就是代码中第2行：if(instance == NULL)和第六行instance = new Singleton();没有正确的同步，在某种情况下会出现new返回了地址赋值给instance变量而Singleton此时还没有构造完全，当另一个线程随后运行到第2行时将不会进入if从而返回了不完全的实例对象给用户使用，造成了严重的错误。在C++11没有出来的时候，只能靠插入两个memory barrier（内存屏障）来解决这个错误，但是C++11引进了memory model，提供了Atomic实现内存的同步访问，即不同线程总是获取对象修改前或修改后的值，无法在对象修改期间获得该对象。”

C++ 单例模式 - 知乎 (zhihu.com)

C++11规定了local static在多线程条件下的初始化行为，要求编译器保证了内部静态变量的线程安全性。在C++11标准下，《Effective C++》提出了一种更优雅的单例模式实现，使用函数内的 local static 对象。这样，只有当第一次访问getInstance()方法时才创建实例。这种方法也被称为Meyers' Singleton。C++0x之后该实现是线程安全的，C++0x之前仍需加锁。

Meyers’ Singleton（也称为Singleton模式或懒汉式Singleton模式）是一种单例模式实现，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。与传统的懒汉式单例模式不同，Meyers’ Singleton在C++中通过使用内部静态类来实现，这是一种在C++11之前常用的方法，因为它能够保证线程安全，同时避免在全局范围内声明静态对象。

Meyers’ Singleton的关键点在于它使用了内部静态类来延迟实例的创建，直到首次使用时才创建实例。内部静态类在类定义时创建，因此它不会被全局实例化，从而避免了全局初始化的开销。

class Singleton {
public:
    static Singleton& getInstance() {
        // 内部静态类，确保在类定义时创建，而不是在全局范围内实例化
        static Singleton instance;
        return instance;
    }

private:
    // 私有构造函数，防止外部通过new创建对象实例
    Singleton() {};

    // 私有拷贝构造函数，防止外部复制对象实例
    Singleton(const Singleton&) = delete;

    // 私有拷贝赋值运算符，防止外部复制对象实例
    Singleton& operator=(const Singleton&) = delete;
};

getInstance方法返回一个内部静态类Singleton的实例。由于Singleton是一个内部静态类，它不会在全局范围内实例化，而是在类定义时实例化。这意味着只有在首次调用getInstance方法时，才会创建单例实例。

Meyers’ Singleton模式提供了一种线程安全的懒汉式单例实现，它避免了全局初始化的开销，并且通过内部静态类保证了线程安全。在C++11之后，可以使用std::call_once或std::once_flag来更简洁地实现单例模式。

饿汉式单例模式

单例实例在程序运行时被立即执行初始化，它确保一个类只有一个实例，并且在类加载时立即创建这个实例。饿汉式单例模式的特点是实例在类加载时就创建，因此不需要在第一次使用时创建，这使得饿汉式单例模式在类加载时就会占用一定的内存。

饿汉式单例模式的优点是简单且线程安全，因为实例在类加载时就已经创建，所以不会出现线程竞争的问题。然而，它的缺点是资源利用率不高，因为实例在类加载时就创建了，即使你从未使用过这个单例。

class Singleton {
private:
    // 私有构造函数，防止外部通过new创建对象实例
    Singleton() {}

    // 私有拷贝构造函数，防止外部复制对象实例
    Singleton(const Singleton&) = delete;

    // 私有拷贝赋值运算符，防止外部复制对象实例
    Singleton& operator=(const Singleton&) = delete;

public:
    // 静态成员变量，在程序启动时创建单例实例
    static const Singleton& getInstance() {
        return instance;
    }

private:
    // 静态成员变量，类加载时初始化
    static const Singleton instance;
};

// 在类外初始化静态成员变量
const Singleton Singleton::instance;

  1. 静态常量成员变量：instance 是一个静态常量成员变量，它在程序启动时创建，并且在整个程序运行期间都存在。

  2. 构造函数和析构函数：由于 instance 是一个常量，因此必须在类外部进行初始化，并且只能通过常量表达式进行初始化。

  3. 线程安全：饿汉式单例模式在程序启动时就创建了单例实例，因此它本身就是线程安全的，不需要担心多线程下的初始化问题。

  4. 常量引用返回：getInstance 方法返回的是对单例实例的常量引用，这防止了对单例实例的修改。

  5. 不需要显式析构函数：由于 instance 是静态常量成员，它的生命周期由系统管理，不需要显式析构。

参考文章：

C++程序员们，快来写最简洁的单例模式吧 - 老司机 - 博客园 (cnblogs.com)

C++中的单例模式 | 神奕的博客 (songlee24.github.io)

Noir间
关注
【C++】C++ 单例模式总结（5种单例实现方法）
unonoi的博客
11-04 9万+
C++ 单例模式的几种实现方式。
C++ 单例模式
热门推荐
qq_43331089的博客
04-22 1万+
C++ 单例模式 一 、单例模式 单例可能是最常用的简单的一种设计模式，实现方法多样，根据不同的需求有不同的写法; 同时单例也有其局限性，因此有很多人是反对使用单例的。本文对C++ 单例的常见写法进行了一个总结, 包括懒汉式、线程安全、单例模板等； 按照从简单到复杂，最终回归简单的的方式循序渐进地介绍，并且对各种实现方法的局限进行了简单的阐述，大量用到了C++ 11的特性如智能指针, magic static，线程锁; 从头到尾理解下来，对于学习和巩固C++语言特性还是很有帮助的。 1、什么是单例 单例 S
c++ 单例模式
weixin_45672157的博客
06-16 951
单例模式（SingletonPattern）是一种常用的程序设计模式，属于创建型设计模式的一种。它的核心思想在于控制类的实例化过程，确保在任何情况下，对于特定类来说，在整个应用程序中只存在一个实例，并提供一个全局访问点来获取这个实例。这样做可以确保共享资源的有效管理，减少系统开销，以及在需要全局访问和协调控制时提供便利。唯一性：确保一个类只有一个实例。全局访问点：提供一个全局访问的方法，让其他对象可以轻松地获取到这个唯一的实例。
C++单例模式详解
见牛羊的博客
02-05 2553
起因是在程序中重复声明了一个单例模式的变量，后来程序怎么调都不对，最后发现变量是用单例模式，修改是全局的，所以决定好好梳理一下单例模式。首先，为什么要用单例模式，就是因为我们希望一个类只有唯一一个实例，并且提供一个全局的访问点。从这个描述不难看出，这个实例应该是要static来修饰的。。
C++ 单例模式 实现
暮色尽染的博客
07-17 1206
单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问该实例。
总结C++单例模式
发如雪
07-04 1282
总结C++单例模式，包括懒汉式、饿汉式、回收
C++ 单例模式 浅谈
树欲静静风不止止的博客
11-16 726
帮助自己和读者更好的理解c++设计模式。
c++单例模式
weixin_48617416的博客
05-17 317
单例模式 目的：一个类只能创建一个对象 使用场景： 需要生成唯一序列的环境 需要频繁实例化然后销毁的对象。 创建对象时耗时过多或者耗资源过多，但又经常用到的对象。 方便资源相互通信的环境 优点： 实现了对唯一实例访问的可控 对于一些需要频繁创建和销毁的对象来说可以提高系统的性能。 缺点： 不适用于变化频繁的对象 滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出。 如果实例化的对象长时间不被利用，系统会认为该对象是垃圾而被
c++单例模式线程日志类
11-22
在C++编程中，单例模式是一种常用的软件设计模式，它保证一个类只有一个实例，并提供一个全局访问点。在这个特定的场景中，我们讨论的是一个实现了单例模式的日志类，该类专为多线程环境设计，具备日志等级控制、...
C++ 单例模式的几种实现方式研究
08-26
"C++ 单例模式的几种实现方式研究" 单例模式是设计模式中最常应用的一种模式，也是面试官最喜欢的题目。但是，如果没有学过设计模式的人，可能不会想到要去应用单例模式，面对单例模式适用的情况。 单例模式的主要...
C++单例模式应用实例
12-31
本文实例讲述了C++单例模式及其相关应用方法，分享给大家供大家参考。具体方法分析如下： 定义： 一个类有且仅有一个实例，并且提供一个访问它的全局访问点。 要点： 1、类只能有一个实例； 2、必须自行创建此实例；...
PyQt 的Tree Widget中拖放和点击的异常行为
weixin_44617651的博客
10-10 255
在 PyQt 的 ​​QTreeWidget​​ 中，如果你遇到 拖放 和 点击 的异常行为，可能是由于信号处理、事件拦截、拖放设置或树结构配置等问题导致的。以下是一些可能的常见问题和解决方案。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1254
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
c_cpp_properties.json文件的作用
最新发布
程序员黄老师的精品课！
10-10 33
IntelliSense 是 VS Code 中内置的一个有用工具，它提供各种代码编辑功能，可帮助您更快、更高效地编写代码。例如，代码完成、参数信息、语法突出显示、代码操作（灯泡）和成员列表都是使用 IntelliSense 生成的。IntelliSense 配置存储在文件中，该文件在您的工作区中自动创建。如何产生 c_cpp_properties.json文件？这里配置一下头文件，就可以自动提示了，以OpenCV为例子。其中的属性可以在界面上改,文件会自动同步。
windows C++-创建数据流代理(三)
苏洛的博客
10-08 298
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 1085
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
C - Separated Lunch
m0_74304371的博客
10-05 467
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值