设计模式13-单件模式

写在前面
- 对象性能模式
- 典型模式
- - 1. 单例模式（Singleton Pattern）
  - 2. 享元模式（Flyweight Pattern）
  - 3. 原型模式（Prototype Pattern）
  - 4. 对象池模式（Object Pool Pattern）
  - 5. 延迟初始化（Lazy Initialization）
  - 6. 虚拟代理（Virtual Proxy）
  - 7. 缓存（Caching）
  - 8. 数据传输对象（DTO，Data Transfer Object）
动机
- - 单例模式的定义
  - 单例模式的结构
  - 单例模式的代码推导
  - 2. 线程安全版本，但锁的代价过高
  - 3. 双检查锁，但由于内存读写reorder不安全
  - 4. C++11版本之后的跨平台实现（volatile）
  - - volatile关键字
  - 平台限制和使用场景
  - 多线程编程中的问题
  - 推荐的跨平台多线程同步机制
  - 总结
  - 单例模式的应用
  - 单例模式的特点总结

写在前面

对象性能模式

面向对象很好的解决了抽象的问题，但是必不可免的要付出一定的代价（类空间的重复分配等）。对于通常情况来讲，面向对象的成本大多都可以忽略不计。但某些情况面向对象所在的成本必须谨慎处理。
设计模式中的对象性能模式是指那些专注于提高系统性能、优化资源使用和管理的设计模式。这些模式通过有效的对象创建、共享、复用和管理策略，减少内存占用、提高运行效率，从而提升整体系统性能。

典型模式

单例模式（Singleton Pattern）
享元模式（Flyweight Pattern）
当然也有一些其他的模式。

设计模式中涉及对象性能优化的模式主要包括以下几种

1. 单例模式（Singleton Pattern）

单例模式确保一个类只有一个实例，并提供全局访问点。这种模式避免了重复创建对象的开销，特别是在需要频繁访问的场景中，如配置类、日志类等。

2. 享元模式（Flyweight Pattern）

享元模式通过共享对象来减少内存使用。它特别适用于有大量相似对象的场景，例如字符处理、图形绘制等。

3. 原型模式（Prototype Pattern）

原型模式通过复制现有对象来创建新对象，从而减少了创建新对象的开销。这种模式适用于创建代价高昂的对象，如大型数据结构、复杂对象等。

4. 对象池模式（Object Pool Pattern）

对象池模式维护一个对象池，复用池中的对象而不是每次都创建和销毁对象。它适用于对象创建和销毁成本较高的情况，如数据库连接、线程等。

5. 延迟初始化（Lazy Initialization）

延迟初始化是指对象的创建或初始化在其实际被使用时才进行。这可以减少程序启动时的资源占用，并将资源分配推迟到实际需要时。

6. 虚拟代理（Virtual Proxy）

虚拟代理是一种代理模式，通过代理对象来控制对实际对象的访问。虚拟代理可以延迟实际对象的创建或初始化，从而优化性能。例如，大型图片的加载可以通过虚拟代理延迟到实际需要时再进行。

7. 缓存（Caching）

缓存模式通过存储之前计算或创建的结果来减少重复计算或创建的开销。这种模式广泛应用于各种性能优化场景，如数据库查询结果缓存、计算结果缓存等。

8. 数据传输对象（DTO，Data Transfer Object）

DTO模式通过一次性传输批量数据来减少多次远程调用的开销。它适用于分布式系统中，通过减少网络通信次数来提高性能。

动机

在软件系统中经常有这样一些特殊的类必须保证他们在系统中只存在一个实例。才能保证他们的逻辑的正确性以及良好的效率。如何绕过常规的构造器提供一种机制来保证一个类只有一个实例呢？让使用者只需使用一个类？这显然不合理。因为这应该是类设计者的责任，而不是使用者的责任。模式就是为了解决这一类问题的模式。

more动机：

在许多应用中，有一些对象需要全局唯一，比如配置文件管理器、日志管理器等。为了确保这些对象在整个应用中只存在一个实例，并且能被全局访问，我们需要一种机制来限制实例化次数并提供统一的访问方式。
单例模式的主要动机是控制对象的实例化过程，确保一个类只有一个实例，并提供一个访问它的全局访问点

单例模式的定义

保证一个类仅有一个实力，并提供一个该实例的全局访问点。

单例模式的结构

结构：

Singleton类：
- 定义一个静态变量来保存类的唯一实例。
- 提供一个静态方法用于创建或获取该实例。
- 将构造函数设为私有，防止外部通过new操作符实例化该类。

以下是单例模式的UML图：

在这里插入图片描述

单例模式的代码推导




class Singleton{
private:
    Singleton();
    Singleton(const Singleton& other);
public:
    static Singleton* getInstance();
    static Singleton* m_instance;
};

Singleton* Singleton::m_instance=nullptr;

//线程非安全版本
Singleton* Singleton::getInstance() {
    if (m_instance == nullptr) {
        m_instance = new Singleton();
    }
    return m_instance;
}






//线程安全版本，但锁的代价过高
Singleton* Singleton::getInstance() {
    Lock lock;
    if (m_instance == nullptr) {
        m_instance = new Singleton();
    }
    return m_instance;
}









//双检查锁，但由于内存读写reorder不安全
Singleton* Singleton::getInstance() {
    
    if(m_instance==nullptr){
        Lock lock;
        if (m_instance == nullptr) {
            m_instance = new Singleton();
        }
    }
    return m_instance;
}








//C++ 11版本之后的跨平台实现 (volatile)
std::atomic<Singleton*> Singleton::m_instance;
std::mutex Singleton::m_mutex;

Singleton* Singleton::getInstance() {
    Singleton* tmp = m_instance.load(std::memory_order_relaxed);
    std::atomic_thread_fence(std::memory_order_acquire);//获取内存fence
    if (tmp == nullptr) {
        std::lock_guard<std::mutex> lock(m_mutex);
        tmp = m_instance.load(std::memory_order_relaxed);
        if (tmp == nullptr) {
            tmp = new Singleton;
            std::atomic_thread_fence(std::memory_order_release);//释放内存fence
            m_instance.store(tmp, std::memory_order_relaxed);
        }
    }
    return tmp;
}

这段代码展示了不同版本的单例模式的实现，包括线程不安全版本、线程安全但性能不佳的版本、双检查锁版本以及C++11之后的跨平台实现。以下是对每个版本的详细说明：

### 1. 线程不安全版本

```cpp
class Singleton{
private:
    Singleton();
    Singleton(const Singleton& other);
public:
    static Singleton* getInstance();
    static Singleton* m_instance;
};

Singleton* Singleton::m_instance = nullptr;

Singleton* Singleton::getInstance() {
    if (m_instance == nullptr) {
        m_instance = new Singleton();
    }
    return m_instance;
}

说明：

这个版本中，getInstance方法检查m_instance是否为空，如果为空则创建一个新的Singleton实例。
这种实现方式在单线程环境中是安全的，但在多线程环境中可能导致多个线程同时创建多个实例，违背单例模式的初衷。

2. 线程安全版本，但锁的代价过高

Singleton* Singleton::getInstance() {
    Lock lock;
    if (m_instance == nullptr) {
        m_instance = new Singleton();
    }
    return m_instance;
}

说明：

这个版本使用了锁（例如std::mutex）来确保线程安全。
虽然保证了线程安全，但每次调用getInstance方法都需要获取锁，代价较高，可能影响性能。

3. 双检查锁，但由于内存读写reorder不安全

Singleton* Singleton::getInstance() {
    if (m_instance == nullptr) {
        Lock lock;
        if (m_instance == nullptr) {
            m_instance = new Singleton();
        }
    }
    return m_instance;
}

说明：

双检查锁的目的是在进入锁之前先检查m_instance是否为空，以减少获取锁的次数，提高性能。
但是，由于编译器和CPU可能对内存读写操作进行重新排序，这种实现方式可能不安全。因为在所有编译器中会对代码进行优化处理，对于new Singleton操作在某些情况下可能会先返回分配空间的指针，后调用构造函数，那么此时第二个线程可能在进行第一个实例判空判断时直接返回指针，但此时这个指针是不可用的，也就是说线程可能看到未完全构造的对象。

4. C++11版本之后的跨平台实现（volatile）

#include <atomic>
#include <mutex>

class Singleton{
private:
    Singleton() {}
    Singleton(const Singleton& other) = delete;
    Singleton& operator=(const Singleton& other) = delete;
public:
    static Singleton* getInstance();
    static std::atomic<Singleton*> m_instance;
    static std::mutex m_mutex;
};

std::atomic<Singleton*> Singleton::m_instance{nullptr};
std::mutex Singleton::m_mutex;

Singleton* Singleton::getInstance() {
    Singleton* tmp = m_instance.load(std::memory_order_relaxed);
    std::atomic_thread_fence(std::memory_order_acquire); // 获取内存fence
    if (tmp == nullptr) {
        std::lock_guard<std::mutex> lock(m_mutex);
        tmp = m_instance.load(std::memory_order_relaxed);
        if (tmp == nullptr) {
            tmp = new Singleton;
            std::atomic_thread_fence(std::memory_order_release); // 释放内存fence
            m_instance.store(tmp, std::memory_order_relaxed);
        }
    }
    return tmp;
}