单例设计模式共享数据分析 解决 call_once

最新推荐文章于 2025-12-06 13:32:24 发布
原创 最新推荐文章于 2025-12-06 13:32:24 发布 · 121 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式 #c++

在C++编程中，单例设计模式用于确保类只有一个实例。在C++11之前，为了保证多线程环境下的线程安全，创建单例可能需要加锁。然而，从C++11开始，静态初始化的线程安全性使得如`GetInstance`方法所示的代码无需额外的锁也能确保线程安全。这段代码在C++11之后的版本中，通过静态局部变量的初始化保证了线程安全的单例实例化。

单例设计模式共享数据问题分析、解决

面临的问题：需要我们自己创建的线程中来创建单例，这个线程不止一个。

static SingleCls *GetInstance()
    {
        // c++11之后这种写法是安全的,由static保证
        if (m_instance == nullptr)
        {
            m_instance = new SingleCls;
            static GC gc;
        }
        return m_instance;
    }

上面代码如果是C++11之前就需要加锁

C++11并发与多线程笔记（7） 单例设计模式共享数据分析、解决，call_once
qq_38231713的博客
05-13 4215
第七节 单例设计模式共享数据分析、解决，call_once 1.设计模式 程序灵活，维护起来可能方便，用设计模式理念写出来的代码很晦涩，但是别人接管、阅读代码都会很痛苦 老外应付特别大的项目时，把项目的开发经验、模块划分经验，总结整理成设计模式 中国零几年设计模式刚开始火时，总喜欢拿一个设计模式往上套，导致一个小小的项目总要加几个设计模式，本末倒置 设计模式有其独特的优点，要活学活用，不要深陷其中，生搬硬套 2.单例设计模式： 整个项目中，有某个或者某些特殊的类，只能创建一个属于该类的对象。 单例类：
（八）单例设计模式共享数据分析， call_once
u011886519的博客
02-23 306
单例模式： 整个项目中只能有一个单例类对象，不能创建多个； 简单实现的例子： //单例类 class MySingleClass { private: MySingleClass() {};//私有化构造函数 这样就不能创建多个对象了 private: static MySingleClass* m_instance; public: static MySingleClass* GetInstance() { if (m_instance == NULL) { m_instance
单例设计模式共享数据分析解决、call_once
weixin_42136255的博客
05-15 322
一：一个可以回收的单例设计模式的类代码 // test.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 #include <iostream> #include <string> #include <vector> #include <stack> #include <queue> #include <map> #include <set> #include <list> #incl
7.单例设计模式共享数据分析、解决、call_once
weixin_42636062的博客
09-11 307
目录 一、设计模式 程序灵活，维护起来可能方便，用设计模式理念写出来的代码很晦涩，但是别人接管、阅读代码都会很痛苦 老外应付特别大的项目时，把项目的开发经验、模块划分经验，总结整理成设计模式 中国零几年设计模式刚开始火时，总喜欢拿一个设计模式往上套，导致一个小小的项目总要加几个设计模式，本末倒置 设计模式有其独特的优点，要活学活用，不要深陷其中，生搬硬套 二、单例设计模式 整个项目中，有某个或者某些特殊的类，只能创建一个属于该类的对象。 单例类：只能生成一个对象。 三、单例设计模式共享数据分析、解决
（C++11/14/17学习笔记）：单例设计模式共享数据分析，call_once()函数
baidu_41388533的博客
12-09 262
目录 单例设计模式共享数据分析、解决，call_once 设计模式大概谈 单例设计模式 单例设计模式共享数据问题分析、解决 std::call_once(） 单例设计模式共享数据分析、解决，call_once 设计模式大概谈 "设计模式"：代码的一些写法（这些写法跟常规写法还不怎么一样），程序灵活，维护起来可能方便，但是别人接管、阅读代码都很痛苦。 用“设计模式”理念写出来的代码很晦涩的。 老外应付特别大的项目的时候，把项目的开发经验、模块划分经验，总结整理成设计模式（现有开发需求
6.单例设计模式共享数据分析，call_once
John的博客
08-31 166
单例设计模式 #include<iostream> #include<thread> #include<vector> #include<string> #include<queue> #include<mutex> using namespace std; class MyCAS {//单例类 private: MyCAS() {}//私有化构造函数 static MyCAS * m_instance;//静态成员变量 pub
并发与多线程（4）单例设计模式共享数据分析 和call_once
weixin_39354845的博客
10-31 254
单例模式已经线程安全性
Th7：单例设计模式共享数据问题的分析和解决，call_once
weixin_44980842的博客
12-23 376
《1》设计模式大概谈 所谓“设计模式”，指的是代码的一些写法（这些写法与常规的写法不一样）。它会使得程序变得灵活，维护起来可能方便。但，用设计模式理念写出来的代码很晦涩，别人接管、阅读代码都会很痛苦，需要下很大功夫才能搞clear。 设计模式最先是老外应付特别大的项目时，把项目的开发经验、模块划分经验，总结整理而成的。0几年设计模式在中国刚开始火时，程序员们总喜欢拿一个设计模式往项目代码上套，导致一个小小的项目总要加几个设计模式，这就本末倒置了。 但不可...
单例设计模式共享数据分析、解决，call_once
INGNIGHT的专栏
08-24 269
一、设计模式大概谈 “设计模式”：代码的一些写法，与常规的写法不太一样，程序灵活，维护起来很方便，但是别人接管、阅读代码很痛苦。 用“设计模式”理念写出来的代码很晦涩。<< head first>> 老外应付特别大的项目时候，把项目开发经验、模块划分经验，总结成设计模式。（现有开发需求，后有理论总结和整理） 设计模式拿到中国来，不太一样，拿着一个程序（项目）往设计模...
单例设计模式 共享数据分析、解决、call_once
CherryBlossom_的博客
11-07 419
std::call_once()就是通过这个标记决定对应函数a()是否执行，调用call_once()成功后，std::call_once()就把这个标记设置为一种已调用状态，后续继续调用std::call_once()，只要once_flag被设置为了“已调用”状态，那么对应的函数a()就不会再被执行了；std::call_once()需要与一个标记结合使用，这个标记std::once_flag;单例：整个项目中，有某个或者某些特殊的类，属于该类的对象，我只能创建一个，多了我创建不了。
c++11多线程并发——单例设计模式共享数据分析（第7讲）
usstmiracle的博客
06-18 447
1）设计模式浅谈 设计模式：代码的一些写法，（这些写法与常规写法不太一样）： 程序灵活，维护起来可能很方便，但是别人接管、阅读代码比较痛苦 用设计模式理念写出来的代码很晦涩《head first》 老外，应付特别大的项目的时候，把项目的开发经验，模块划分经验，总结整理出来的设计模式 先有开发需求，然后有总结和整理。 设计模式到中国来，不太一样，拿着一个程序（项目）往设计模式上套，一个小...
C++11 并发与多线程（七、单例设计模式共享数据分析）
芒种、的博客
06-13 239
一、单例设计模式 class Test { public: static Test *GetInstance() { if (nullptr == ptrTest) { ptrTest = new Test(); static Delete cl; //定义一个静态释放对对象 } return ptrTest; } class Delete //类中嵌套来释放对象 { public: ~Delete() { if (Test::ptrTest) {
c++单例设计模式及多线程
William辰的博客
04-22 1371
1、单例设计模式 1 #include<iostream> 2 using namespace std; ...
【C++单例设计模式】：创建、销毁、线程安全的终极指南
单例设计模式是软件设计领域中非常经典的一种模式，它的核心思想是在整个应用程序的生命周期中，某个类只生成一个实例。这种设计模式经常被应用在需要确保一个类只有一个实例且该实例易于被外部访问的场景中。单例...
C++ 设计模式之观察者模式详细介绍
XiaoBinbest的博客
12-02 757
抽象接口是解耦的核心，确保被观察者和观察者仅依赖抽象，不依赖具体实现。
23种设计模式-16中介者模式
不开心就吃辣
12-03 826
本文介绍了中介者模式（Mediator Pattern），这是一种行为设计模式，通过中介对象封装一组对象的交互，减少对象间的直接依赖，提高代码的可扩展性和可维护性。文章分析了适用场景（对象交互复杂、逻辑分散、需提高复用性），详细说明了模式结构（中介者接口、具体中介者、同事类），并提供了Java实现的聊天应用示例代码。该模式类似于现实中的中介角色，能有效处理对象间交互，适用于需要解耦复杂对象关系的场景。
23种设计模式-17备忘录模式
不开心就吃辣
12-04 361
简化发起人实体类(Originator）职责，隔离状态存储与获取，实现了信息的封装，客户端 无需关心状态的保存细节；提供回滚功能消耗资源：如果需要保存的状态过多 Memento 类过大时，每一次保存都会消耗很多内存。
Pimpl（Pointer to Implementation）设计模式详解
最新发布
2301_80355452的博客
12-06 620
cpp// 传统方式 - MyClass.hpublic:MyClass();private:// 私有数据成员// 需要包含<vector>// 需要包含<map>// 需要包含第三方头文件// ... 更多实现细节问题编译依赖：任何包含MyClass.h的文件都会间接包含所有依赖的头文件编译时间长：修改私有成员会导致所有包含此头文件的文件重新编译暴露实现细节：用户能看到私有成员，违反了封装原则。
从装饰者到桥接再到工厂：模式组合的艺术
m0_72755177的博客
12-02 812
装饰者就像套娃，每个娃娃外表看起来都一样，但大娃娃里面套着小娃娃。：桥接模式让两个维度"门当户对、平等合作"，而不是一个依附另一个。// 正确的：“目前有3种配料，用简单方案，等真有10种时再重构”有些维度应该平等相处。：设计一个游戏角色系统，有职业（战士、法师）和装备（剑、法杖）传统继承需要：红圆、蓝圆、红方、蓝方 → 4个类。装备不是"装饰"职业，装备可以独立存在。装饰者模式说："别急，我们来玩俄罗斯套娃！// 第二版：发现需要加配料 → 引入装饰者。5种配料（糖、奶、奶油、焦糖、肉桂）
qtc++ 智能指针和call_once实现单例模式
07-28
<think>我们使用Qt框架，但智能指针和call_once是C++11标准库的内容，可以在Qt项目中使用。 目标：使用智能指针（如std::shared_ptr）和std::call_once实现线程安全的单例模式。 步骤： 1. 单例类：将构造函数、拷贝构造函数、赋值运算符私有化或删除，以防止外部创建实例。 2. 使用静态成员变量：一个静态的std::shared_ptr指向单例对象，以及一个静态的std::once_flag用于保证初始化只执行一次。 3. 提供一个公共的静态成员函数获取单例对象，在该函数内使用std::call_once来初始化单例对象。 注意：由于std::call_once是线程安全的，因此可以保证在多线程环境下只初始化一次。 代码示例： ```cpp #include <memory> #include <mutex> // 包含std::once_flag和std::call_once class Singleton { public: // 删除拷贝构造函数和赋值运算符，确保单例唯一性 Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; // 获取单例对象的静态方法 static std::shared_ptr<Singleton> getInstance() { std::call_once(initInstanceFlag, &Singleton::initSingleton); return instance; } private: Singleton() {} // 私有构造函数 // 静态成员变量 static std::shared_ptr<Singleton> instance; static std::once_flag initInstanceFlag; // 用于初始化单例对象的函数 static void initSingleton() { instance = std::shared_ptr<Singleton>(new Singleton()); } }; // 静态成员变量需要在类外初始化 std::shared_ptr<Singleton> Singleton::instance = nullptr; std::once_flag Singleton::initInstanceFlag; ``` 但是，上述代码在C++11中，静态局部变量的初始化是线程安全的，所以还有一种更简洁的写法（Meyers' Singleton）： 不过这里题目要求使用智能指针和call_once，所以我们按上述方式实现。 然而，我们也可以使用局部静态变量，但这里我们使用智能指针，并且希望使用std::call_once。 但是注意：上述代码中，我们使用了一个静态的std::shared_ptr，并且通过std::call_once来初始化它。 另外，我们也可以使用std::unique_ptr，因为单例模式通常希望只有一个所有者（虽然shared_ptr也可以，但单例通常不需要共享所有权，因为单例对象在程序运行期间一直存在，不会被删除）。但是，使用shared_ptr可以方便地支持弱引用，并且当程序需要释放单例时（比如在程序退出时），可以通过重置shared_ptr来释放。不过，单例通常在整个程序运行期间都存在，所以这里使用shared_ptr或unique_ptr都可以，但shared_ptr更常见于可能需要提前释放或需要弱指针的场景。 如果我们使用unique_ptr，则修改如下： ```cpp class Singleton { public: Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; static Singleton* getInstance() { std::call_once(initInstanceFlag, &Singleton::initSingleton); return instance.get(); } private: Singleton() {} static std::unique_ptr<Singleton> instance; static std::once_flag initInstanceFlag; static void initSingleton() { instance.reset(new Singleton()); } }; std::unique_ptr<Singleton> Singleton::instance = nullptr; std::once_flag Singleton::initInstanceFlag; ``` 但是，通常我们更倾向于返回引用或原始指针（因为单例的生命周期由单例类自己管理，不需要外部管理），而使用智能指针内部管理主要是为了自动释放。不过，在程序退出时，静态成员变量的析构顺序可能导致问题（比如在单例被析构后，其他静态对象还试图访问它）。使用原始指针则不会自动释放，但我们可以接受，因为单例对象在程序结束时由系统回收（除非有资源需要释放，如文件句柄、网络连接等）。 因此，为了确保资源释放，我们可以使用智能指针来管理，并在程序退出时自动释放。 但是，如果我们使用shared_ptr，那么当最后一个引用释放时，对象就会被销毁。而单例模式通常希望在整个程序运行期间都存在，所以我们需要保证这个shared_ptr不会被意外释放（比如通过getInstance返回的shared_ptr的拷贝被销毁不会影响，因为静态成员instance还存在）。因此，我们返回shared_ptr的拷贝是安全的。 不过，使用unique_ptr的话，我们只能返回原始指针，因为unique_ptr不允许拷贝。这样，外部就只能通过原始指针访问单例，而无法控制单例的生命周期。这符合单例模式的特点。 因此，两种方式都可以，这里我选择使用shared_ptr，因为这样外部也可以持有智能指针，但注意不要重置这个智能指针。 另外，在Qt中，我们可能还需要考虑QObject的父子对象关系，但单例通常没有父对象。 但是，如果单例类继承自QObject，则需要注意：QObject不允许拷贝，所以我们的单例类如果是QObject的派生类，那么拷贝构造函数和赋值运算符已经被删除了，所以不需要再写。另外，QObject的构造函数可以指定父对象，但单例对象没有父对象，所以构造时不要传递父对象。 下面给出一个继承自QObject的单例类示例（使用shared_ptr）： ```cpp #include <QObject> #include <memory> #include <mutex> class Singleton : public QObject { Q_OBJECT public: static std::shared_ptr<Singleton> getInstance() { std::call_once(initInstanceFlag, &Singleton::initSingleton); return instance; } // 删除拷贝构造和赋值 Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; private: Singleton(QObject *parent = nullptr) : QObject(parent) { // 初始化代码 } static std::shared_ptr<Singleton> instance; static std::once_flag initInstanceFlag; static void initSingleton() { instance = std::make_shared<Singleton>(); } }; // 静态成员初始化 std::shared_ptr<Singleton> Singleton::instance = nullptr; std::once_flag Singleton::initInstanceFlag; ``` 注意：在Qt中，如果使用QObject，那么对象树管理可能会影响析构。但这里我们使用智能指针，当程序结束时，静态成员变量会析构，从而释放单例对象。由于单例对象没有父对象，所以不会在父对象析构时被删除，而是由智能指针管理。 另外，如果单例对象在析构时需要执行一些操作（如保存状态），可以在析构函数中实现。 但是，使用std::call_once和智能指针，我们实现了线程安全的单例模式。 相关问题： 1. 为什么使用std::call_once比双重检查锁定更优？ 2. 在单例模式中，使用std::shared_ptr和std::unique_ptr有什么区别？ 3. 在Qt中使用单例模式需要注意哪些问题？ 4. 如何确保单例对象在程序退出时安全释放资源？</think>### Qt C++ 使用智能指针和 std::call_once 实现线程安全的单例模式 以下是使用 `std::shared_ptr` 和 `std::call_once` 实现线程安全单例模式的完整代码： ```cpp #include <memory> #include <mutex> #include <QCoreApplication> class Singleton { public: // 获取单例实例的静态方法 static std::shared_ptr<Singleton> getInstance() { std::call_once(initFlag, &Singleton::init); // 保证只初始化一次 return instance; } // 删除拷贝构造和赋值运算符 Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; // 示例成员函数 void doSomething() { qDebug() << "Singleton instance at: " << this; } private: Singleton() = default; // 私有构造函数 ~Singleton() = default; // 私有析构函数 static void init() { // 实际初始化函数 instance.reset(new Singleton()); } static std::shared_ptr<Singleton> instance; // 智能指针管理实例 static std::once_flag initFlag; // 初始化控制标志 }; // 静态成员初始化 std::shared_ptr<Singleton> Singleton::instance = nullptr; std::once_flag Singleton::initFlag; int main(int argc, char *argv[]) { QCoreApplication app(argc, argv); // 线程安全访问示例 auto threadFunc = []{ auto s = Singleton::getInstance(); s->doSomething(); }; std::thread t1(threadFunc); std::thread t2(threadFunc); t1.join(); t2.join(); return app.exec(); } ``` #### 关键实现说明： 1. **智能指针管理** 使用 `std::shared_ptr` 管理单例生命周期，自动处理内存释放[^2]。 2. **线程安全初始化** `std::call_once` 配合 `std::once_flag` 确保多线程环境下只执行一次初始化[^1]。 3. **禁用拷贝操作** 显式删除拷贝构造函数和赋值运算符，防止意外复制实例。 4. **私有构造函数** 确保只能通过 `getInstance()` 获取实例，防止外部创建。 5. **Qt 集成** 可继承 `QObject` 并在构造函数中添加 Qt 相关功能（如信号槽）。 #### 优势： 1. **线程安全**：无需手动加锁，避免死锁风险[^1][^4] 2. **资源高效**：`call_once` 比互斥锁性能更高 3. **自动内存管理**：智能指针自动处理资源释放 4. **延迟初始化**：实例在首次调用时创建 > **注意**：如果不需要共享所有权，可将 `std::shared_ptr` 替换为 `std::unique_ptr`，此时 `getInstance()` 需返回原始指针： > ```cpp > static Singleton* getInstance() { > std::call_once(initFlag, []{ instance.reset(new Singleton()); }); > return instance.get(); // 返回原始指针 > } > ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值