单例模式（C++实现）

已于 2023-10-08 00:30:45 修改
阅读量90 收藏
点赞数 1
分类专栏： 设计模式之C++实现 文章标签： 单例模式 c++ 算法
于 2023-10-06 23:31:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wujian0108/article/details/133624783
版权

1.饿汉模式

class TaskQueue
{
public:
  // = delete 代表函数禁用, 也可以将其访问权限设置为私有
  TaskQueue(const TaskQueue& obj) = delete;
  TaskQueue& operator=(const TaskQueue& obj) = delete;
  static TaskQueue* getInstance()
  {
    return m_taskQ;
  }
private:
  TaskQueue() = default;
  static TaskQueue* m_taskQ;
};
//静态成员初始化放到类外部处理
TaskQueue* TaskQueue::m_taskQ = new TaskQueue;
int main()
{
  TaskQueue* obj = TaskQueue::getInstance();
}

2.懒汉模式

2.1一把互斥锁实现

//加了一把互斥锁，解决多线程问题，但是性能不好
#include <iostream>
#include <queue>
#include <mutex>
#include <thread>
class TaskQueue
{
public:
    // = delete 代表函数禁用, 也可以将其访问权限设置为私有
    TaskQueue(const TaskQueue& obj) = delete;
    TaskQueue& operator=(const TaskQueue& obj) = delete;
    static TaskQueue* getInstance()
    {
        m_mutex.lock();
        if (m_taskQ == nullptr)
        {
            m_taskQ = new TaskQueue;
        }
        m_mutex.unlock();
        return m_taskQ;
    }
private:
    TaskQueue() = default;
    static TaskQueue* m_taskQ;
    static std::mutex m_mutex;
};
TaskQueue* TaskQueue::m_taskQ = nullptr;
std::mutex TaskQueue::m_mutex;
int main()
{
    TaskQueue* obj = TaskQueue::getInstance();
}

2.2 静态局部对象实现

//静态局部对象:在实现懒汉模式的单例的时候，相较于双重检查锁定模式有一种更简单的实现方法并且不会出现线程安全问题，那就是使用静态局部局部对象
#include <iostream>
#include <queue>
using namespace std;

class TaskQueue
{
public:
    // = delete 代表函数禁用, 也可以将其访问权限设置为私有
    TaskQueue(const TaskQueue& obj) = delete;
    TaskQueue& operator=(const TaskQueue& obj) = delete;
    static TaskQueue* getInstance()
    {
        static TaskQueue taskQ;
        return &taskQ;
    }
    void print()
    {
        cout << "hello, world!!!" << endl;
    }

private:
    TaskQueue() = default;
};

int main()
{
    TaskQueue* queue = TaskQueue::getInstance();
    queue->print();
    return 0;
}

2.3 原子变量实现

#include <iostream>
#include <queue>
#include <mutex>
#include <thread>
#include <atomic>
using namespace std;
class TaskQueue
{
public:
    // = delete 代表函数禁用, 也可以将其访问权限设置为私有
    TaskQueue(const TaskQueue& obj) = delete;
    TaskQueue& operator=(const TaskQueue& obj) = delete;
    static TaskQueue* getInstance()
    {
        TaskQueue* queue = m_taskQ.load();  
        if (queue == nullptr)
        {
            // m_mutex.lock();  // 加锁: 方式1
            lock_guard<mutex> locker(m_mutex);  // 加锁: 方式2
            queue = m_taskQ.load();
            if (queue == nullptr)
            {
                queue = new TaskQueue;
                m_taskQ.store(queue);
            }
            // m_mutex.unlock();
        }
        return queue;
    }

    void print()
    {
        cout << "hello, world!!!" << endl;
    }
private:
    TaskQueue() = default;
    static atomic<TaskQueue*> m_taskQ;
    static mutex m_mutex;
};
atomic<TaskQueue*> TaskQueue::m_taskQ;
mutex TaskQueue::m_mutex;

int main()
{
    TaskQueue* queue = TaskQueue::getInstance();
    queue->print();
    return 0;
}

3.分析

3.1 更推荐懒汉模式

懒汉模式的缺点是在创建实例对象的时候有安全问题，但这样可以减少内存的浪费（如果用不到就不去申请内存了）。

饿汉模式则相反，在我们不需要这个实例对象的时候，它已经被创建出来，占用了一块内存。对于现在的计算机而言，内存容量都是足够大的，这个缺陷可以被无视。

4.单例模式的模板和继承

4.1 Meyer’s Singleton

Scott Meyers 在 Effective C++ 的 Item 4: Make sure that objects are initialized before they’re used 里面提出了一种利用 C++ 的 static 关键字来实现的单例模式，这种实现非常简洁高效，它的特点是：

  1. 仅当程序第一次执行到 GetInstance 函数时，执行 instance 对象的初始化；
  2. 在 C++ 11 之后，被 static 修饰的变量可以保证是线程安全的；（即：如果指令逻辑进入一个未被初始化的声明变量，所有并发执行应当等待该变量完成初始化。）
template<typename T>
class Singleton
{
public:
    static T& GetInstance()
    {
        static T instance;
        return instance;
    }

    Singleton(T&&) = delete;
    Singleton(const T&) = delete;
    void operator= (const T&) = delete;

protected:
    Singleton() = default;
    virtual ~Singleton() = default;
};

通过禁用单例类的 copy constructor，move constructor 和 operator= 可以防止类的唯一实例被拷贝或移动；不暴露单例类的 constructor 和 destructor 可以保证单例类不会通过其他途径被实例化，同时将两者定义为 protected 可以让其被子类继承并使用。

4.2 Eager Singleton

和 Lazy Singleton 相反，Eager Singleton 利用 static member variable 的特性，在程序进入 main 函数之前进行初始化，这样就绕开了线程安全的问题：

template<typename T>
class EagerSingleton
{
private:
    static T* t_;

public:
    static T& GetInstance()
    {
        return *t_;
    }

    EagerSingleton(T&&) = delete;
    EagerSingleton(const T&) = delete;
    void operator= (const T&) = delete;

protected:
    EagerSingleton() = default;
    virtual ~EagerSingleton() = default;
};

template<typename T>
T* EagerSingleton<T>::t_ = new (std::nothrow) T;

但是它也有两个问题：

  1. 即使单例对象不被使用，单例类对象也会进行初始化；
  2. static initialization order fiasco，即 t_ 对象和 GetInstance 函数的初始化先后顺序是不固定的；

4.3 Lazy Singleton

Lazy Singleton 是一种比较传统的实现方法，通过其名字可以看出来它也具有 lazy-evaluation 的特点，但在实现的时候需要考虑线程安全的问题：

template<typename T, bool is_thread_safe = true>
class LazySingleton
{
private:
    static unique_ptr<T> t_;
    static mutex mtx_;

public:
    static T& GetInstance()
    {
        if (is_thread_safe == false)
        {
            if (t_ == nullptr)
                t_ = unique_ptr<T>(new T);
            return *t_;
        }

        if (t_ == nullptr)
        {
            unique_lock<mutex> unique_locker(mtx_);
            if (t_ == nullptr)
                t_ = unique_ptr<T>(new T);
            return *t_;
        }

    }

    LazySingleton(T&&) = delete;
    LazySingleton(const T&) = delete;
    void operator= (const T&) = delete;

protected:
    LazySingleton() = default;
    virtual ~LazySingleton() = default;
};

template<typename T, bool is_thread_safe>
unique_ptr<T> LazySingleton<T, is_thread_safe>::t_;

template<typename T, bool is_thread_safe>
mutex LazySingleton<T, is_thread_safe>::mtx_;

我们通过模板参数 is_thread_safe 来控制这个类是否是线程安全的，因为在某些场景下我们会希望每个线程拥有一个实例：

  1. 当 is_thread_safe == false，即非线程安全时，我们在 GetInstance 函数中直接判断，初始化并返回单例对象；这里使用了 unique_ptr 防止线程销毁时发生内存泄漏，也可以在析构函数中销毁指针；
  2. 当 is_thread_safe == true 时，我们通过 double-checked locking 来进行检查并加锁，防止单例类在每个线程上都被实例化。

5.TaskQueue实战

#include <functional>
#include <memory>
#include<string>
#include <iostream>
#include <queue>
#include <mutex>
#include <thread>
//单例模板类
template<typename T>
class EagerSingleton
{
private:
    static T* t_;

public:
    static T* GetInstance()
    {
        return t_;
    }

    EagerSingleton(T&&) = delete;
    EagerSingleton(const T&) = delete;
    void operator= (const T&) = delete;

protected:
    EagerSingleton() = default;
    virtual ~EagerSingleton() = default;
};
// 任务队列的类，继承自单例模板类
template<typename T>
T* EagerSingleton<T>::t_ = new (std::nothrow) T;

class TaskQueue :public EagerSingleton<TaskQueue>
{
public:
    // 任务队列是否为空
    bool isEmpty()
    {
        std::lock_guard<std::mutex> locker(m_mutex);
        bool flag = m_taskQ.empty();
        return flag;
    }

    // 添加任务
    void addTask(std::function<void()> task)
    {
        std::lock_guard<std::mutex> locker(m_mutex);
        m_taskQ.push(task);
    }

    // 从队列中取出一个任务
    std::function<void()> getTask() 
    { 
        std::lock_guard<std::mutex> locker(m_mutex); // 上锁
        if (m_taskQ.empty()) { // 队列为空，返回空函数
            return [] {};
        }
        auto task = m_taskQ.front(); // 取出队首元素
        m_taskQ.pop(); // 出队
        return task; // 返回任务函数
    }

    // 删除一个任务
    bool popTask()
    {
        std::lock_guard<std::mutex> locker(m_mutex);
        if (!m_taskQ.empty())
        {
            m_taskQ.pop();
            return true;
        }
        return false;
    }
private:
    std::queue<std::function<void()>> m_taskQ;
    std::mutex m_mutex;
};

// WorkItem 类的定义，是一个抽象的基类
class WorkItem {
public:
    // 构造函数，接受一个任务名
    WorkItem(const std::string& name) : name_(name) {}

    // 虚析构函数，用于支持多态
    virtual ~WorkItem() {}

    // 纯虚函数，用于执行任务的具体逻辑，由子类实现
    virtual void run() = 0;

    // 获取任务名
    std::string getName() const {
        return name_;
    }

private:
    std::string name_; // 任务名
};

// PrintTask 类的定义，继承自 WorkItem 类
class PrintTask : public WorkItem {
public:
    // 构造函数，调用基类的构造函数
    PrintTask(const std::string& name) : WorkItem(name) {}

    // 重写 run 方法，打印任务名
    void run() override {
        std::cout << "###Running task: " << getName() << "### ";
    }
};
int main()
{

    // 创建三个任务对象
    std::thread t1([]() {
        TaskQueue* taskQ = TaskQueue::GetInstance();
        for (int i = 0; i < 100; ++i)
        {
            auto task = std::make_shared<PrintTask>("task" + std::to_string(i + 100));
            taskQ->addTask(std::bind(&PrintTask::run, task));
            std::cout << "+++push task: " << i + 100 << ", threadID: "
                << std::this_thread::get_id() << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(500));
        }
        });
    std::thread t2([]() {
        TaskQueue* taskQ = TaskQueue::GetInstance();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        while (!taskQ->isEmpty())
        {
            std::cout << "---take task: "; taskQ->getTask()();
            std::cout << " threadID: "
                << std::this_thread::get_id() << std::endl;
            taskQ->getTask()();
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        });
    std::thread t3([]() {
        TaskQueue* taskQ = TaskQueue::GetInstance();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        while (!taskQ->isEmpty())
        {
            std::cout << "---take task: "; taskQ->getTask()();
            std::cout << " threadID: "
                << std::this_thread::get_id() << std::endl;
            taskQ->getTask()();
            std::this_thread::sleep_for(std::chrono::seconds(1));

            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        });
    t1.join();
    t2.join();
    t3.join();
}
j10n
关注
专栏目录
单例模式的实现（C++）
qq_41904210的博客
08-31 505
实现单例模式 单例模式的目的是使得类的一个对象成为系统中的唯一实例。通过单例模式的方法创建的类在当前进程中只有一个实例 (根据需要，也有可能一个线程中属于单例，如：仅线程上下文内使用同一个实例) 1、饿汉模式 /* * 饿汉模式 * 1. 线程安全的因为代码在跑起来的时候，类就已经被实例化出来了 * 2. 但是不支持延迟加载，即不能在使用时才创建它 */ class Singleton { public: static Singleton *getInstance(); private:
单例模式C++实现
知行且执行
09-16 904
单例模式了解一般情况下，我们需要一些工具性质的类，这种类没有太多跟自身有关的数据。若每次使用时都new一个实例会增加不必要的开销，也是代码臃肿，其实我们只需要一个实例即可。若是采用全局变量或是静态变量方式，虽然可以实现但是影响了封装性。此时我们可以使用设计模式中的Singleton模式，我们把构造函数声明为private, 这样就不会被外部new了。常见的单例模式主要分两种，一种是在声明时立即实例化
C++常用设计模式1——单例模式
凛冬烈焰的博客
06-13 388
最近在学习各种设计模式，感觉收获非常多。首先推荐一个视频：https://www.bilibili.com/video/av22292899，不太清楚原版的课程在哪里。这个课的老师讲得非常透彻，听完后有种醍醐灌顶之感。我们知道，C++是一种支持面向对象编程的语言。所谓“面向对象”的三大特性，相信大家都已经滚瓜烂熟：封装、继承、多态。但很多人在实际编程过程中，只是知道皮毛而不是领会“面向对象”的精髓...
C++静态局部变量的妙用：Meyer’s Singleton单例模式
qq_44886707的博客
12-31 679
静态局部变量在 Meyer's Singleton中的妙用
最安全的C++单例模式——Meyers’ Singleton
脸红哥的博客
10-29 2571
class Singleton { private: Singleton(); public: static Singleton&amp; getInstance() {     static Singleton instance;     return instance;     } }
用C++实现单例模式4——C++11实现
q5707802的专栏
02-04 2756
1.static local      Scott Meyer在《Effective C++》中提出了一种简洁的singleton写法。 template class Singleton { public: static T& getInstance() { static T value; return value; } private: Singleton()
单例模式及C++实现代码
weixin_30555125的博客
06-21 454
单例模式 单例模式，可以说设计模式中最常应用的一种模式了，据说也是面试官最喜欢的题目。但是如果没有学过设计模式的人，可能不会想到要去应用单例模式，面对单例模式适用的情况，可能会优先考虑使用全局或者静态变量的方式，这样比较简单，也是没学过设计模式的人所能想到的最简单的方式了。 一般情况下，我们建立的一些类是属于工具性质的，基本不用存储太多的跟自身有关的数据，在这种情况下，每次都去new一个对象，...
单例模式 C++ 实现
05-01
在C++中实现单例模式，通常有几种常见的方法： 1. **懒汉式**：也称为延迟初始化，只有当第一次调用单例对象时才创建实例。这种做法避免了在程序启动时就创建不必要的对象。不过，如果多个线程同时尝试创建实例，...
使用C++11实现线程安全的单例模式
04-05
C++11引入了新的特性，如std::mutex和std::call_once，使得实现线程安全的单例模式变得更加容易和高效。 首先，我们需要理解C++11中的线程模型。在C++11之前，C++标准并不直接支持多线程编程。C++11引入了 `...
【01_单例模式】c++实现单例
yizhizainulii的博客
04-25 531
问题描述 现在，不管开发一个多大的系统（至少我现在的部门是这样的），都会带一个日志功能；在实际开发过程中，会专门有一个日志模块，负责写日志，由于在系统的任何地方，我们都有可能要调用日志模块中的函数，进行写日志。那么，如何构造一个日志模块的实例呢？难道，每次new一个日志模块实例，写完日志，再delete，不要告诉我你是这么干的。在C++中，可以构造一个日志模块的全局变量，那么在任何地方就都可以用了，是的，不错。但是，我所在的开发部门的C++编码规范是参照Google的编码规范的。 全局变量在项目中是能不用就
Headfirst（五）单例模式C++实现
10-21
在C++中实现单例模式，通常有多种方法，包括懒汉式、饿汉式、双重检查锁定（DCL）等。让我们深入探讨这些实现方式及其优缺点。 **一、懒汉式（Lazy Initialization）** 懒汉式单例的特点是在首次使用时才创建对象，...
单例模式（C++实现懒汉式）
zhongzhh8的博客
12-30 3299
单例模式是设计模式中的一种，本文记录和总结单例模式的定义以及C++中实现单例模式的几种懒汉式方式。 参考C++ 单例模式总结与剖析 什么是单例模式 单例（Singleton）模式的特点是这个类在全局只有唯一的一个实例对象，在所有位置都可以通过该类提供的接口访问到这个唯一实例。最经典的使用场景是公用缓存，由一个线程周期性地写，由多个线程读取，此时就可以用单例模式来保证不同线程写和读的是同一个实例。 C++实现单例模式，有几个基础要点： 保证全局只有一个实例。通过把构造函数设置为private可以防止用户
单例模式详解
qq_42798343的博客
09-16 872
饿汉式：类加载时创建实例，简单但可能会浪费内存资源。懒汉式：实例延迟到第一次使用时才创建，节省资源，但需要处理线程安全问题。静态内部类：优雅的解决方案，结合了懒加载、线程安全和性能的优点。枚举方式：最推荐的实现方式，简单、安全，且能防止反射和序列化破坏。单例模式虽然简单，但在高并发环境下实现需要特别注意线程安全问题。同时，序列化和反射可能会破坏单例，需要采取额外的防御措施，如和反射保护机制。
C++单例模式
小小白的日常分享
09-12 523
在C++中，单例模式是一种确保一个类只有一个实例，并提供一个全局访问点来访问这个实例的设计模式。单例模式中的饿汉式（Eager Initialization）和懒汉式（Lazy Initialization）是两种不同的实例化策略，它们在实例的创建时机、性能和线程安全性方面有所区别。
设计模式之单例模式
最新发布
一个老Java开发的自白
09-16 587
单例模式是一种简单而强大的设计模式，它通过确保一个类只有一个实例来简化对共享资源的访问和管理。在实际应用中，我们应该根据具体需求和场景来选择合适的单例实现方式，并注意解决线程安全、延迟加载、序列化等问题。同时，也要避免滥用单例模式，保持代码的清晰和可维护性。
Python中的单例模式：从入门到精通
qq_44771627的博客
09-11 688
单例模式是一种常用的软件设计模式，它保证了一个类只有一个实例，并提供一个全局访问点。这种模式通常用于那些需要频繁创建和销毁的对象，比如日志对象、线程池、缓存等场景，可以有效减少资源消耗，提高系统性能。在Python中实现单例模式不仅简单直观，而且能够很好地融入到各种框架和库中，使得程序更加高效稳定。
【C++】【网络】【Linux系统编程】单例模式，加锁封装TCP/IP协议套接字
2301_79796701的博客
09-16 848
给系统，表明这个套接字所期望的、还未处理的（即还在等待被接受的连接）连接请求的最大队列长度。换句话说，它告诉系统内核为这个套接字分配多大的空间来存储尚未处理的连接请求。有关套接字编程的细节和更多的系统调用课参考《UNIX环境高级编程》一书，可以在如下网站搜索电子版，该书在第16章详细的介绍了各种接口。我们可以根据自己的需求，用面向对象的思想封装出接口简洁的类。在类似添加一个该类类型的指针，该指针是静态的并且是私有成员。结构体填充，为了使不同的地址格式能和套接字绑定，需要把对应的结构体强转成通用地址结构。
C#开发基础之单例模式下的集合数据，解决并发访问读写冲突的问题
dotnet研习社
09-16 781
在C#中，使用单例模式管理集合数据时，如果多线程同时访问集合，容易产生并发访问的读写冲突问题。单例模式下集合数据的并发访问读写冲突是如何产生的？单例模式确保一个类在整个应用运行期间只有一个实例，这使得单例对象成为全局共享的资源。当这个单例对象包含集合数据（如List、Dictionary等），并且这些集合数据被多个线程同时访问时，就可能产生并发读写冲突。以上几种方法可以有效解决单例模式下集合数据的并发访问问题。具体选择哪种方法取决于你的应用场景和性能需求。
C++实现单例模式详解
以下是C++中实现单例模式的示例代码： ```cpp class CSingleton { private: CSingleton() {} // 私有构造函数，防止外部实例化 static CSingleton* m_pInstance; // 私有静态指针 public: static CSingleton* ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值