Singleton(单例模式)

🕗 发布于 2024-10-06 07:01 c++ 开发语言

1. 意图

在开发中，若某些模块或功能只需要一个类实例，所有调用地方通过着一个类对象访问功能，单例模式符合这种类实例创建模式，并且通过提供统一类实例接口访问类对象。

2. 适用性

《Gof 设计模式-可复用面向对象软件的基础》中对此模式的适用性描述如下：

当类只能有一个实例且客户可以从一个公众的访问点访问。
当这个唯一实例应该是通过子类化可拓展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

3. 实现

饿汉模式：类加载时，类对象创建并初始化，调用时直接使用已经创建好的。

#include <iostream>

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

  void Print() { std::cout << __FUNCTION__ << std::endl; }

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

private:
  static Singleton *m_instance;
};

Singleton *Singleton::m_instance = new Singleton;

void Test() { Singleton::GetInstance()->Print(); }

int main() {
  Test();
  return 0;
}

懒汉模式：类对象创建与初始化被延迟到真正调用的位置。

#include <iostream>

class Singleton {
public:
  static Singleton *GetInstance() {
    if (m_instance == nullptr)
      m_instance = new Singleton;
    return m_instance;
  }

  void Print() { std::cout << __FUNCTION__ << std::endl; }

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

private:
  static Singleton *m_instance;
};

Singleton *Singleton::m_instance = nullptr;

void Test() { Singleton::GetInstance()->Print(); }

int main() {
  Test();
  return 0;
}

懒汉模式存在多线程并发问题，可以加锁，如下

#include <iostream>
#include <mutex>

std::mutex mtx;

class Singleton {
public:
  static Singleton *GetInstance() {
    std::lock_guard<std::mutex> locker(mtx);
    if (m_instance == nullptr)
      m_instance = new Singleton;
    return m_instance;
  }

  void Print() { std::cout << __FUNCTION__ << std::endl; }

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

private:
  static Singleton *m_instance;
};

以上通过加锁保证了数据的并发安全，但若此对象创建好后多个线程频繁调用，每次都加锁访问可读对象，对程序性能影响较大，于是又出现了双层检查机制，优化访问性能。

#include <iostream>
#include <mutex>

std::mutex mtx;

class Singleton {
public:
  static Singleton *GetInstance() {
    if (m_instance == nullptr) {
      std::lock_guard<std::mutex> locker(mtx);
      if (m_instance == nullptr)
        m_instance = new Singleton;
    }
    return m_instance;
  }

  void Print() { std::cout << __FUNCTION__ << std::endl; }

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

private:
  static Singleton *m_instance;
};

Singleton *Singleton::m_instance = nullptr;

void Test() { Singleton::GetInstance()->Print(); }

int main() {
  Test();
  return 0;
}

双重检查机制实际上还存在潜在的问题，内存访问重新排序（重新排列编译器产生的汇编指令）导致双重锁定失效（考虑类对象内存分配和调用构造函数初始化分为两步执行，指令不顺序执行就无法保证多线程有其它指令在这两步之间执行）。所以需要保证指令顺序执行，避免指令重排。

#include <atomic>
#include <iostream>
#include <mutex>

class Singleton {
public:
  static Singleton *GetInstance() {
    Singleton *tmp = m_instance.load(std::memory_order_relaxed);
    std::atomic_thread_fence(std::memory_order_acquire);
    if (tmp == nullptr) {
      std::lock_guard<std::mutex> locker(m_mtx);
      tmp = m_instance.load(std::memory_order_relaxed);
      if (tmp == nullptr) {
        tmp = new Singleton;
        std::atomic_thread_fence(std::memory_order_release);
        m_instance.store(tmp, std::memory_order_relaxed);
      }
    }
    return m_instance;
  }

  void Print() { std::cout << __FUNCTION__ << std::endl; }

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

private:
  static std::atomic<Singleton *> m_instance;
  static std::mutex m_mtx;
};

std::atomic<Singleton *> Singleton::m_instance = nullptr;
std::mutex Singleton::m_mtx;

void Test() { Singleton::GetInstance()->Print(); }

int main() {
  Test();
  return 0;
}

以上使用原子变量及内存序约束实现单例类，避免指令重排问题，同时解决并发问题。但实现略微繁琐，c++11以后对静态变量创建的并发安全提供了保证，简化写法如下：

#include <iostream>

class Singleton {
public:
  static Singleton &GetInstance() {
    static Singleton instance;
    return instance;
  }

  void Print() { std::cout << __FUNCTION__ << std::endl; }

private:
  Singleton() = default;
  ~Singleton() = default;
  Singleton(const Singleton &) = delete;
  Singleton &operator=(const Singleton &) = delete;
};

void Test() { Singleton::GetInstance().Print(); }

int main() {
  Test();
  return 0;
}

4. 优缺点

控制类实例数量
比类操作更灵活，减少命名空间污染
隐藏了类之间的依赖关系
影响代码的扩展性
影响代码的可测试性
不支持包含参数的构造函数

5. 模板实现

单实例管理

template <typename T> class SingletonManager {
public:
  template <typename... Args> static T &GetInstance(Args &&...args) {
    static T instance(std::forward<Args>(args)...);
    return instance;
  }

private:
  SingletonManager() = default;
  virtual ~SingletonManager() = default;
  SingletonManager(const SingletonManager &) = delete;
  SingletonManager &operator=(const SingletonManager &) = delete;
};

多实例管理

#include <map>
#include <memory>
#include <string>

template <typename T, typename K = std::string> class MultitonManager {
public:
  template <typename... Args>
  static T &GetInstance(const K &key, Args &&...args) {
    return AssignInstance(key, std::forward<Args>(args)...);
  }

  template <typename... Args> static T &GetInstance(K &&key, Args &&...args) {
    return AssignInstance(key, std::forward<Args>(args)...);
  }

private:
  template <typename Key, typename... Args>
  static T &AssignInstance(Key &&key, Args &&...args) {
    auto iter = m_map.find(key);
    if (iter == m_map.end()) {
      static T instance;
      m_map.emplace(key, &instance);
      return instance;
    }
    return *(iter->second);
  }

private:
  MultitonManager() = default;
  virtual ~MultitonManager() = default;
  MultitonManager(const MultitonManager &) = delete;
  MultitonManager &operator=(const MultitonManager &) = delete;

private:
  static std::map<K, T *> m_map;
};

template <typename T, typename K> std::map<K, T *> MultitonManager<T, K>::m_map;

原文地址：https://blog.csdn.net/TimerSea/article/details/142718935

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：十二、血条UI
下一篇：开源模型应用落地-模型微调-模型研制-模型训练（二）

成为一名厉害的黑客，必须知道的12个步骤，黑客入门
与许多较老的UNIX书籍不同，这是一本相对较新的Linux书籍，这本书是由Michael Kerrisk编写的，他是Linux手册的维护成员之一，与许多作者一样，他从1987年开始研究UNIX，并从2
阅读更多2024-10-10
麒麟桌面版v10 SP1以docker方式安装达梦数据库
的构建版本信息：使用的是麒麟（Kylin）桌面版系统，具体版本为Kylin-Desktop V10-SP1-hwe，构建日期为2021年8月20日。直接 GitHub 下载：docker/compos
阅读更多2024-10-10
【Unity游戏开发】PlayerInput最佳实践，自动生成actions代码
新输入系统主要有两种方式，一种是全局的InputActions直接用new获取另一种是在组件上挂载PlayerInpput，好处是可以区分不同玩家，精细的禁用单个行为，但是使用比较麻烦最重要的还是要用
阅读更多2024-10-10
ubuntu 18.04虚拟机以太网网段与地平线J6板端连接配置
板端ip可以ping通，同时联网也可以。选择自动获取IP地址。
阅读更多2024-10-10
k8s部署学习
8s的架构一个kubernetes集群主要是由控制节点(master)、工作节点(node)构成，每个节点上都会安装不同的组件1 master：集群的控制平面，负责集群的决策ApiServer : 资
阅读更多2024-10-10
【技术支持】家里智能电视不能联网重置小米路由器之路
本文记录了由于家庭中小米盒子网络问题，进而引发使用小米路由器重置网络的一系列操作
阅读更多2024-10-10
python 自学总结
位置传递的不定长， def 函数名（*args）: 传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，args是元组的类型，这就是位置传递。# 关键字传递的不定长 de
阅读更多2024-10-10
JavaScript 第2章基本语法
通过这些示例，读者可以更好地理解JavaScript的基本语法，并学会如何在实际的业务场景中应用这些语法。通过这些示例，读者可以进一步理解JavaScript中的变量声明、数据类型、运算符以及语句的使
阅读更多2024-10-10
java内置的四种函数式接口
四种内置函数式接口
阅读更多2024-10-10
系统移植二和网卡移植实验和私有驱动LED的移植
驱动文件的集成：通过修改 Kconfig 和 Makefile 文件，将驱动集成到内核中，并在 menuconfig 中显示配置项。驱动的编译方式：可以选择将驱动编译到内核中（内建）或编译为模块（动态
阅读更多2024-10-10