恋恋风辰的官方博客

再谈单例模式
Posted on 2023-02-24 10:39:11 by 恋恋风辰 | In C++ | 原文链接

本文介绍C++单例模式的集中实现方式，以及利弊

局部静态变量方式

  1. //通过静态成员变量实现单例
  2. //懒汉式
  3. class Single2
  4. {
  5. private:
  6.     Single2()
  7.     {
  8.     }
  9.     Single2(const Single2 &) = delete;
  10.     Single2 &operator=(const Single2 &) = delete;
  12. public:
  13.     static Single2 &GetInst()
  14.     {
  15.         static Single2 single;
  16.         return single;
  17.     }
  18. };

上述代码通过局部静态成员single实现单例类，原理就是函数的局部静态变量生命周期随着进程结束而结束。上述代码通过懒汉式的方式实现。
调用如下

  1. void test_single2()
  2. {
  3.     //多线程情况下可能存在问题
  4.     cout << "s1 addr is " << &Single2::GetInst() << endl;
  5.     cout << "s2 addr is " << &Single2::GetInst() << endl;
  6. }

程序输出如下

  1. sp1  is  0x1304b10
  2. sp2  is  0x1304b10

确实生成了唯一实例，上述单例模式存在隐患，对于多线程方式生成的实例可能时多个。

静态成员变量指针方式

可以定义一个类的静态成员变量，用来控制实现单例

  1. //饿汉式
  2. class Single2Hungry
  3. {
  4. private:
  5.     Single2Hungry()
  6.     {
  7.     }
  8.     Single2Hungry(const Single2Hungry &) = delete;
  9.     Single2Hungry &operator=(const Single2Hungry &) = delete;
  11. public:
  12.     static Single2Hungry *GetInst()
  13.     {
  14.         if (single == nullptr)
  15.         {
  16.             single = new Single2Hungry();
  17.         }
  18.         return single;
  19.     }
  21. private:
  22.     static Single2Hungry *single;
  23. };

这么做的一个好处是我们可以通过饿汉式的方式避免线程安全问题

  1. //饿汉式初始化
  2. Single2Hungry *Single2Hungry::single = Single2Hungry::GetInst();
  3. void thread_func_s2(int i)
  4. {
  5.     cout << "this is thread " << i << endl;
  6.     cout << "inst is " << Single2Hungry::GetInst() << endl;
  7. }
  8. void test_single2hungry()
  9. {
  10.     cout << "s1 addr is " << Single2Hungry::GetInst() << endl;
  11.     cout << "s2 addr is " << Single2Hungry::GetInst() << endl;
  13.     for (int i = 0; i < 3; i++)
  14.     {
  15.         thread tid(thread_func_s2, i);
  16.         tid.join();
  17.     }
  18. }
  19. int main(){
  20.     test_single2hungry()
  21. }

程序输出如下

  1. s1 addr is 0x1e4b00
  2. s2 addr is 0x1e4b00
  3. this is thread 0
  4. inst is 0x1e4b00
  5. this is thread 1
  6. inst is 0x1e4b00
  7. this is thread 2
  8. inst is 0x1e4b00

可见无论单线程还是多线程模式下，通过静态成员变量的指针实现的单例类都是唯一的。饿汉式是在程序启动时就进行单例的初始化，这种方式也可以通过懒汉式调用，无论饿汉式还是懒汉式都存在一个问题，就是什么时候释放内存？多线程情况下，释放内存就很难了，还有二次释放内存的风险。
我们定义一个单例类并用懒汉式方式调用

  1. //懒汉式指针
  2. //即使创建指针类型也存在问题
  3. class SinglePointer
  4. {
  5. private:
  6.     SinglePointer()
  7.     {
  8.     }
  10.     SinglePointer(const SinglePointer &) = delete;
  11.     SinglePointer &operator=(const SinglePointer &) = delete;
  13. public:
  14.     static SinglePointer *GetInst()
  15.     {
  16.         if (single != nullptr)
  17.         {
  18.             return single;
  19.         }
  21.         s_mutex.lock();
  22.         if (single != nullptr)
  23.         {
  24.             s_mutex.unlock();
  25.             return single;
  26.         }
  27.         single = new SinglePointer();
  28.         s_mutex.unlock();
  29.         return single;
  30.     }
  32. private:
  33.     static SinglePointer *single;
  34.     static mutex s_mutex;
  35. };

在cpp文件里初始化静态成员,并定义一个测试函数

  1. //懒汉式
  2. //在类的cpp文件定义static变量
  3. SinglePointer *SinglePointer::single = nullptr;
  4. std::mutex SinglePointer::s_mutex;
  6. void thread_func_lazy(int i)
  7. {
  8.     cout << "this is lazy thread " << i << endl;
  9.     cout << "inst is " << SinglePointer::GetInst() << endl;
  10. }
  12. void test_singlelazy()
  13. {
  14.     for (int i = 0; i < 3; i++)
  15.     {
  16.         thread tid(thread_func_lazy, i);
  17.         tid.join();
  18.     }
  20.     //何时释放new的对象？造成内存泄漏
  21. }
  23. int main(){
  24.     test_singlelazy();
  25. }

函数输出如下

  1. this is lazy thread 0
  2. inst is 0xbc1700
  3. this is lazy thread 1
  4. inst is 0xbc1700
  5. this is lazy thread 2
  6. inst is 0xbc1700

此时生成的单例对象的内存空间还没回收，这是个问题，另外如果多线程情况下多次delete也会造成崩溃。

智能指针方式

可以利用智能指针自动回收内存的机制设计单例类

  1. //利用智能指针解决释放问题
  2. class SingleAuto
  3. {
  5. private:
  6.     SingleAuto()
  7.     {
  8.     }
  10.     SingleAuto(const SingleAuto &) = delete;
  11.     SingleAuto &operator=(const SingleAuto &) = delete;
  13. public:
  14.     ~SingleAuto()
  15.     {
  16.         cout << "single auto delete success " << endl;
  17.     }
  19.     static std::shared_ptr<SingleAuto> GetInst()
  20.     {
  21.         if (single != nullptr)
  22.         {
  23.             return single;
  24.         }
  26.         s_mutex.lock();
  27.         if (single != nullptr)
  28.         {
  29.             s_mutex.unlock();
  30.             return single;
  31.         }
  32.         single = std::shared_ptr<SingleAuto>(new SingleAuto);
  33.         s_mutex.unlock();
  34.         return single;
  35.     }
  37. private:
  38.     static std::shared_ptr<SingleAuto> single;
  39.     static mutex s_mutex;
  40. };

SingleAuto的GetInst返回std::shared_ptr<SingleAuto>类型的变量single。因为single是静态成员变量，所以会在进程结束时被回收。智能指针被回收时会调用内置指针类型的析构函数，从而完成内存的回收。
在主函数调用如下测试函数

  1. // 智能指针方式
  2. std::shared_ptr<SingleAuto> SingleAuto::single = nullptr;
  3. mutex SingleAuto::s_mutex;
  4. void test_singleauto()
  5. {
  6.     auto sp1 = SingleAuto::GetInst();
  7.     auto sp2 = SingleAuto::GetInst();
  8.     cout << "sp1  is  " << sp1 << endl;
  9.     cout << "sp2  is  " << sp2 << endl;
  10.     //此时存在隐患，可以手动删除裸指针，造成崩溃
  11.     // delete sp1.get();
  12. }
  13. int main(){
  14.     test_singleauto();
  15. }

程序输出如下

  1. sp1  is  0x1174f30
  2. sp2  is  0x1174f30

智能指针方式不存在内存泄漏，但是有一个隐患就是单例类的析构函数时public的，如果被人手动调用会存在崩溃问题，比如将上边test_singleauto中的注释打开，程序会崩溃。

辅助类智能指针单例模式

智能指针在构造的时候可以指定删除器，所以可以传递一个辅助类或者辅助函数帮助智能指针回收内存时调用我们指定的析构函数。

  1. // safe deletor
  2. //防止外界delete
  3. //声明辅助类
  4. //该类定义仿函数调用SingleAutoSafe析构函数
  5. //不可以提前声明SafeDeletor，编译时会提示incomplete type
  6. // class SafeDeletor;
  7. //所以要提前定义辅助类
  8. class SingleAutoSafe;
  9. class SafeDeletor
  10. {
  11. public:
  12.     void operator()(SingleAutoSafe *sf)
  13.     {
  14.         cout << "this is safe deleter operator()" << endl;
  15.         delete sf;
  16.     }
  17. };
  18. class SingleAutoSafe
  19. {
  20. private:
  21.     SingleAutoSafe() {}
  22.     ~SingleAutoSafe()
  23.     {
  24.         cout << "this is single auto safe deletor" << endl;
  25.     }
  26.     SingleAutoSafe(const SingleAutoSafe &) = delete;
  27.     SingleAutoSafe &operator=(const SingleAutoSafe &) = delete;
  28.     //定义友元类，通过友元类调用该类析构函数
  29.     friend class SafeDeletor;
  31. public:
  32.     static std::shared_ptr<SingleAutoSafe> GetInst()
  33.     {
  34.         if (single != nullptr)
  35.         {
  36.             return single;
  37.         }
  39.         s_mutex.lock();
  40.         if (single != nullptr)
  41.         {
  42.             s_mutex.unlock();
  43.             return single;
  44.         }
  45.         //额外指定删除器
  46.         single = std::shared_ptr<SingleAutoSafe>(new SingleAutoSafe, SafeDeletor());
  47.         //也可以指定删除函数
  48.         // single = std::shared_ptr<SingleAutoSafe>(new SingleAutoSafe, SafeDelFunc);
  49.         s_mutex.unlock();
  50.         return single;
  51.     }
  53. private:
  54.     static std::shared_ptr<SingleAutoSafe> single;
  55.     static mutex s_mutex;
  56. };

SafeDeletor要写在SingleAutoSafe上边，并且SafeDeletor要声明为SingleAutoSafe类的友元类，这样就可以访问SingleAutoSafe的析构函数了。
我们在构造single时制定了SafeDeletor(),single在回收时，会调用SingleAutoSafe的仿函数，从而完成内存的销毁。
并且SingleAutoSafe的析构函数为私有的无法被外界手动调用了。

  1. //智能指针初始化为nullptr
  2. std::shared_ptr<SingleAutoSafe> SingleAutoSafe::single = nullptr;
  3. mutex SingleAutoSafe::s_mutex;
  5. void test_singleautosafe()
  6. {
  7.     auto sp1 = SingleAutoSafe::GetInst();
  8.     auto sp2 = SingleAutoSafe::GetInst();
  9.     cout << "sp1  is  " << sp1 << endl;
  10.     cout << "sp2  is  " << sp2 << endl;
  11.     //此时无法访问析构函数，非常安全
  12.     // delete sp1.get();
  13. }
  15. int main(){
  16.     test_singleautosafe();
  17. }

程序输出如下

  1. sp1  is  0x1264f30
  2. sp2  is  0x1264f30

通过辅助类调用单例类的析构函数保证了内存释放的安全性和唯一性。这种方式时生产中常用的。如果将test_singleautosafe函数的注释打开，手动delete sp1.get()编译阶段就会报错，达到了代码安全的目的。因为析构被设置为私有函数了。

通用的单例模板类

我们可以通过声明单例的模板类，然后继承这个单例模板类的所有类就是单例类了。达到泛型编程提高效率的目的。

  1. template <typename T>
  2. class Single_T
  3. {
  4. protected:
  5.     Single_T() = default;
  6.     Single_T(const Single_T<T> &st) = delete;
  7.     Single_T &operator=(const Single_T<T> &st) = delete;
  8.     ~Single_T()
  9.     {
  10.         cout << "this is auto safe template destruct" << endl;
  11.     }
  13. public:
  14.     static std::shared_ptr<T> GetInst()
  15.     {
  16.         if (single != nullptr)
  17.         {
  18.             return single;
  19.         }
  21.         s_mutex.lock();
  22.         if (single != nullptr)
  23.         {
  24.             s_mutex.unlock();
  25.             return single;
  26.         }
  27.         //额外指定删除器
  28.         single = std::shared_ptr<T>(new T, SafeDeletor_T<T>());
  29.         //也可以指定删除函数
  30.         // single = std::shared_ptr<SingleAutoSafe>(new SingleAutoSafe, SafeDelFunc);
  31.         s_mutex.unlock();
  32.         return single;
  33.     }
  35. private:
  36.     static std::shared_ptr<T> single;
  37.     static mutex s_mutex;
  38. };
  40. //模板类的static成员要放在h文件里初始化
  41. template <typename T>
  42. std::shared_ptr<T> Single_T<T>::single = nullptr;
  44. template <typename T>
  45. mutex Single_T<T>::s_mutex;

我们定义一个网络的单例类，继承上述模板类即可，并将构造和析构设置为私有，同时设置友元保证自己的析构和构造可以被友元类调用.

  1. //通过继承方式实现网络模块单例
  2. class SingleNet : public Single_T<SingleNet>
  3. {
  4. private:
  5.     SingleNet() = default;
  6.     SingleNet(const SingleNet &) = delete;
  7.     SingleNet &operator=(const SingleNet &) = delete;
  8.     ~SingleNet() = default;
  9.     friend class SafeDeletor_T<SingleNet>;
  10.     friend class Single_T<SingleNet>;
  11. };

在主函数中调用如下

  1. void test_singlenet()
  2. {
  3.     auto sp1 = SingleNet::GetInst();
  4.     auto sp2 = SingleNet::GetInst();
  5.     cout << "sp1  is  " << sp1 << endl;
  6.     cout << "sp2  is  " << sp2 << endl;
  7. }

程序输出如下

  1. sp1  is  0x1164f30
  2. sp2  is  0x1164f30

总结

本文介绍了一些面试常见问题
源码链接
https://gitee.com/secondtonone1/cpplearn
想系统学习更多C++知识,可点击下方链接。
C++基础

热门评论
点击查看更多评论 没有更多评论了,点击收起 展开评论

热门文章

  1. Qt环境搭建
    喜欢(517) 浏览(25506)

  2. vscode搭建windows C++开发环境
    喜欢(596) 浏览(86135)

  3. 聊天项目(28) 分布式服务通知好友申请
    喜欢(507) 浏览(6240)

  4. 使用hexo搭建个人博客
    喜欢(533) 浏览(12241)

  5. Linux环境搭建和编码
    喜欢(594) 浏览(13991)

最新评论

  1. string类 WangQi888888:确实错了，应该是！isspace(sind[index]). 否则不进入循环，还是原来的字符串“some string”
  2. 利用C11模拟伪闭包实现连接的安全回收 搁浅:看chatgpt说 直接传递 shared_from_this() 更安全 提问： socket_.async_read_some(boost::asio::buffer(data_, BUFFSIZE), // 接收客户端发生来的数据 std::bind(&Session::handle_read, this, std::placeholders::_1, std::placeholders::_2, shared_from_this())); socket_.async_read_some(boost::asio::buffer(data_, BUFFSIZE), std::bind(&Session::handle_read, shared_from_this(), std::placeholders::_1, std::placeholders::_2)); 这两种方式有区别吗？ 回答 ： 第一种方式：this 是裸指针，可能会导致生命周期问题，虽然 shared_from_this() 提供了一定的保护，但 this 依然存在风险。 第二种方式：完全使用 shared_ptr 来管理生命周期，更加安全。 通常，第二种方式更推荐使用，因为它可以确保在异步操作完成之前，Session 对象的生命周期得到完全管理，避免使用裸指针的潜在风险。
  3. protobuf配置和使用 熊二:你可以把dll放到系统目录，也可以配置环境变量，还能把dll丢到lib里
  4. 可变参数模板+异步队列实现异步打印功能 熊二:学到了%%%
  5. 无锁并发队列 TenThousandOne:_head  和 _tail  替换为原子变量。那里pop的逻辑，val = _data[h] 可以移到循环外面吗
  6. 答疑汇总(thread,async源码分析) Yagus:如果引用计数为0，则会执行 future 的析构进而等待任务执行完成，那么看到的输出将是 这边应该不对吧，std::future析构只在这三种情况都满足的时候才回block: 1.共享状态是std::async 创造的(类型是_Task_async_state) 2.共享状态没有ready 3.这个future是共享状态的最后一个引用 这边共享状态类型是“_Package_state”，引用计数即使为0也不应该block啊
  7. 构造函数 secondtonone1:构造函数是类的基础知识，要着重掌握
  8. 聊天项目(7) visualstudio配置grpc diablorrr:cmake文件得改一下 find_package(Boost REQUIRED COMPONENTS system filesystem)，要加上filesystem。在target_link_libraries中也同样加上
  9. 利用栅栏实现同步 Dzher:作者你好！我觉得 std::thread a(write_x); std::thread b(write_y); std::thread c(read_x_then_y); std::thread d(read_y_then_x); 这个例子中的assert fail并不会发生，原子变量设定了非relaxed内存序后一个线程的原子变量被写入，那么之后的读取一定会被同步的，c和d线程中只可能同时发生一个z++未执行的情况，最终z不是1就是2了，我测试了很多次都没有assert，请问我这个观点有什么错误，谢谢！
  10. Qt 对话框 Spade2077:QDialog w(); //这里是不是不需要带括号
  11. Qt MVC结构之QItemDelegate介绍 胡歌-此生不换:gpt, google
  12. 聊天项目(13) 重置密码功能 Doraemon:万一一个用户多个邮箱呢 有可能的
  13. 聊天项目(15) 客户端实现TCP管理者 lkx:已经在&QTcpSocket::readyRead 回调函数中做了处理了的。
  14. slice介绍和使用 恋恋风辰:切片作为引用类型极大的提高了数据传递的效率和性能，但也要注意切片的浅拷贝隐患，算是一把双刃剑，这世间的常态就是在两极之间寻求一种稳定。
  15. 处理网络粘包问题 zyouth: //消息的长度小于头部规定的长度，说明数据未收全，则先将部分消息放到接收节点里 if (bytes_transferred < data_len) { memcpy(_recv_msg_node->_data + _recv_msg_node->_cur_len, _data + copy_len, bytes_transferred); _recv_msg_node->_cur_len += bytes_transferred; ::memset(_data, 0, MAX_LENGTH); _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH), std::bind(&CSession::HandleRead, this, std::placeholders::_1, std::placeholders::_2, shared_self)); //头部处理完成 _b_head_parse = true; return; } 把_b_head_parse = true;放在_socket.async_read_some前面是不是更好
  16. boost::asio之socket的创建和连接 项空月:发现一些错别字 :每隔vector存储  是不是是每个. asio::mutable_buffers_1 o或者    是不是多打了个o
  17. 再谈单例模式 secondtonone1:是的，C++11以后返回局部static变量对象能保证线程安全了。
  18. 类和对象 陈宇航:支持！！！！
  19. 解决博客回复区被脚本注入的问题 secondtonone1:走到现在我忽然明白一个道理，无论工作也好生活也罢，最重要的是开心，即使一份安稳的工作不能给我带来事业上的积累也要合理的舍弃，所以我还是想去做喜欢的方向。
  20. C++ 并发三剑客future, promise和async Yunfei:大佬您好，如果这个线程池中加入的异步任务的形参如果有右值引用，这个commit中的返回类型推导和bind绑定就会出现问题，请问实际工程中，是不是不会用到这种任务，如果用到了，应该怎么解决？
  21. 堆排序 secondtonone1:堆排序非常实用，定时器就是这个原理制作的。
  22. 网络编程学习方法和图书推荐 Corleone:啥程度可以找工作
  23. visual studio配置boost库 一giao里我离giaogiao:请问是修改成这样吗：.\b2.exe toolset=MinGW
  24. 面试题汇总(一) secondtonone1:看到网络上经常提问的go的问题，做了一下汇总，结合自己的经验给出的答案，如有纰漏，望指正批评。
  25. 创建项目和编译 secondtonone1:谢谢支持
  26. C++ 线程安全的单例模式演变 183******95:单例模式的析构函数何时运行呢? 实际测试里：无论单例模式的析构函数为私有或公有，使用智能指针和辅助回收类，两种方法都无法在main()结束前调用单例的析构函数。
  27. 聊天项目(9) redis服务搭建 pro_lin:redis线程池的析构函数，除了pop出队列，还要free掉redis连接把
  28. 基于锁实现线程安全队列和栈容器 secondtonone1:我是博主，你认真学习的样子的很可爱，哈哈，我画的是链表由空变成1个的情况。其余情况和你思考的类似，只不过我用了一个无效节点表示tail的指向，最初head和tail指向的都是这个节点。
  29. interface应用 secondtonone1:interface是万能类型，但是使用时要转换为实际类型来使用。interface丰富了go的多态特性，也降低了传统面向对象语言的耦合性。

其他链接

  1. GitHub
  2. 个人博客
  3. 博客园
  4. CSDN

个人公众号

个人微信