23种经典设计模式：单例模式篇（C++）

news2024/10/1 12:22:36

前言：

博主将从此篇单例模式开始逐一分享23种经典设计模式，并结合C++为大家展示实际应用。内容将持续更新，希望大家持续关注与支持。

什么是单例模式？

单例模式是设计模式的一种（属于创建型模式 (Creational Patterns) )，它确保某个类只有一个实例，并为该实例提供一个全局访问点。它常用于那些在整个系统中只需要一个实例的类，例如配置管理、日志记录、线程池、缓存等。

为什么选择单例模式？

1. 确保唯一性

有些时候，我们需要确保某个对象在整个系统中只存在一个。这样可以避免因为多次实例化导致的资源浪费或不一致性。

2. 节省资源

如果一个对象初始化需要大量资源，例如读取配置文件或建立数据库连接，那么多次实例化就可能导致不必要的开销。

3. 提供全局访问点

这让其他对象可以轻松地访问到该实例，并与之交互。

4. 单例模式的不足：

万事万物都没有绝对的好，不然也不会有23种设计模式，过度依赖单例模式可能使代码变得紧耦合和难以测试。因此，当考虑使用单例模式时，应当仔细权衡其优点和潜在的问题。

单例模式的分类？

单例模式的具体实现？

1. 饿汉式

特点：在类加载时就完成了初始化，静态成员对象的创建是在类加载时完成的。
优点：线程安全（基于类加载机制，避免了多线程同步问题）。
缺点：不是懒加载，可能造成资源浪费。

class Singleton {
private:
    // Singleton的私有静态实例
    static Singleton instance;

    // 私有构造函数确保只能通过getInstance方法来访问Singleton实例
    Singleton() {}

public:
    // 公共静态方法，用于获取Singleton实例
    static Singleton& getInstance() {
        return instance;
    }
};

// 初始化静态的Singleton实例
Singleton Singleton::instance;

2. 懒汉式

特点：在第一次调用时实例化。
优点：懒加载，只有在真正需要对象时才会创建。
缺点：需要处理线程安全问题。

class Singleton {
private:
    // Singleton的私有静态指针实例
    static Singleton* instance;

    // 私有构造函数确保只能通过getInstance方法来访问Singleton实例
    Singleton() {}

public:
    // 公共静态方法，用于获取Singleton实例。如果实例不存在，就创建一个。
    static Singleton* getInstance() {
        if (!instance) { // 判断instance是否为空
            instance = new Singleton(); // 如果为空，则新建一个Singleton对象
        }
        return instance; // 返回Singleton对象的指针
    }
};

// 初始化静态的Singleton指针实例为nullptr
Singleton* Singleton::instance = nullptr;

3. 懒汉式（带锁）

特点：在首次请求对象时创建实例，但加入了互斥锁以确保线程安全。
优势：懒加载，线程安全。
劣势：每次访问时都需要加锁，可能会有性能开销。

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mtx; // 用于同步的互斥锁

    Singleton() {}

public:
    static Singleton* getInstance() {
        std::lock_guard<std::mutex> lock(mtx); // 直接锁定
        if (!instance) {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;

4. 双重检查锁定（DCL, Double Checked Locking）

特点：结合了懒汉式和synchronized同步锁。
优点：懒加载，线程安全，且性能较高。

class Singleton {
private:
    // Singleton的私有静态指针实例
    static Singleton* instance;
    
    // 用于同步的互斥锁
    static std::mutex mtx;

    Singleton() {}

public:
    // 这里使用了双重检查锁定来确保线程安全
    static Singleton* getInstance() {
        if (!instance) { // 第一次检查，不加锁
            std::lock_guard<std::mutex> lock(mtx); // 加锁
            if (!instance) { // 第二次检查，已加锁
                instance = new Singleton(); 
            }
        }
        return instance; 
    }
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;

5. 静态局部变量（C++11)

利用C++11特性，局部静态变量已经是线程安全的，并且无需额外的锁或同步机制。

class Singleton {
public:
    // 公共静态方法，用于获取Singleton实例的引用。
    // 这里利用了局部静态变量的特性，该变量只会初始化一次，并且这个初始化过程在C++11及以上是线程安全的。
    static Singleton& getInstance() {
        static Singleton instance;  // 局部静态变量
        return instance;            // 返回这个局部静态变量的引用
    }

private:
    // 私有构造函数确保只能通过getInstance方法来访问Singleton实例
    Singleton() {}
};

6. 使用`std::once_flag`和`std::call_once`（C++11及以上）:

特点：确保某个代码块只被执行一次。
优势：线程安全，性能较好。
劣势：依赖于C++11及以上版本的特性。

class Singleton {
private:
    // Singleton的私有静态指针实例
    static Singleton* instance;
    static std::once_flag onceFlag;

    // 私有构造函数
    Singleton() {}

public:
    // 删除拷贝构造函数和赋值操作符，确保不能拷贝
    Singleton(const Singleton& other) = delete;
    Singleton& operator=(const Singleton& other) = delete;

    // 公共静态方法，用于获取或创建Singleton实例
    static Singleton* getInstance() {
        std::call_once(onceFlag, []() {
            instance = new Singleton();
        });
        return instance;
    }
};

// 初始化静态成员
Singleton* Singleton::instance = nullptr;
std::once_flag Singleton::onceFlag;

开发中的选择？

在实际开发中，选择单例模式的具体实现通常取决于以下因素：

线程安全性需求：在多线程应用中，单例模式的实现必须是线程安全的。但如果你知道应用永远不会在多线程环境中运行，你可以选择一个不考虑线程安全的简单实现。
性能考虑：某些单例实现（例如每次访问时都加锁的懒汉式）可能会对性能产生负面影响。但在现代硬件上，这种影响通常可以忽略不计，除非你的代码在高频、高并发场景下运行。
C++版本：在C++11及更高版本中，局部静态变量的初始化是线程安全的，这使得某些单例实现变得更为简洁和可靠。

基于上述因素，以下是在实际开发中经常使用的单例模式实现：

局部静态变量（推荐，尤其是C++11及以上）：

这种方法简洁、线程安全，并且无需额外的锁或同步机制。
双重检查锁定（DCL, Double Checked Locking）：这在C++11之前可能是线程安全的选择，但需要谨慎使用，因为在某些老的编译器和硬件上可能会出现问题。
使用std::call_once和std::once_flag：这是C++11及以上版本提供的线程安全方法，可以确保对象只初始化一次。
饿汉式：在程序启动时就创建实例。这种方法简单并且线程安全，但可能会导致不必要的资源浪费，特别是当单例对象很大或初始化成本很高时。
懒汉式（带锁）：在首次请求时创建实例，并使用互斥锁确保线程安全。这种方式在性能敏感的场景中可能不是最佳选择。