＜设计模式＞单例模式

一、什么是单例模式

单例模式（Singleton Pattern）是一种常用的软件设计模式，其核心思想是确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一的实例。这种模式在需要严格控制类的实例数量时非常有用，比如在系统中需要一个共享资源（如配置文件、日志记录器、数据库连接池等）时。

二、单例模式的特点

• 唯一性：一个类只能创建一个实例。

• 全局访问点：提供一个全局的方法来访问这个唯一的实例。

• 控制实例化：通过私有化构造函数，防止外部直接通过 new 关键字创建实例。

三、单例模式的实现

1、饿汉模式

饿汉模式是单例模式的一种实现方式，其核心思想是在类加载时就初始化唯一的实例，而不是等到第一次使用时才初始化

#include <iostream>

class Singleton {
private:
    // 私有静态成员变量，存储唯一的实例
    static Singleton instance;

    // 私有构造函数，防止外部通过 new 创建实例
    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

    // 防止复制构造和赋值操作，确保单例
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    // 提供一个静态方法，返回唯一的实例
    static Singleton& getInstance() {
        return instance;
    }

    // 示例方法
    void showMessage() {
        std::cout << "This is a message from the Singleton instance." << std::endl;
    }
};

// 在类外初始化静态成员变量
Singleton Singleton::instance;

int main() {
    // 获取单例实例
    Singleton& obj1 = Singleton::getInstance();
    Singleton& obj2 = Singleton::getInstance();

    // 检查两个实例是否相同
    std::cout << "obj1 address: " << &obj1 << std::endl;
    std::cout << "obj2 address: " << &obj2 << std::endl;

    // 调用示例方法
    obj1.showMessage();

    return 0;
}

2、懒汉模式(线程不安全)

懒汉模式的核心思想是在第一次调用getInstance()方法时才创建唯一的实例，而不是在类加载时就初始化（饿汉模式）。这种模式的优点是延迟加载，只有在需要时才创建实例，节省资源。但缺点是在多线程环境下可能会出现问题，因为多个线程可能同时检查到实例为空，然后都去创建实例，导致多个实例被创建。

#include <iostream>

class Singleton {
private:
    // 私有静态指针，存储唯一的实例
    static Singleton* instance;

    // 私有构造函数，防止外部通过 new 创建实例
    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

    // 防止复制构造和赋值操作，确保单例
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    // 提供一个静态方法，返回唯一的实例
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    // 释放资源
    ~Singleton() {
        std::cout << "Singleton instance destroyed." << std::endl;
    }

    // 示例方法
    void showMessage() {
        std::cout << "This is a message from the Singleton instance." << std::endl;
    }
};

// 在类外初始化静态成员变量
Singleton* Singleton::instance = nullptr;

int main() {
    // 获取单例实例
    Singleton* obj1 = Singleton::getInstance();
    Singleton* obj2 = Singleton::getInstance();

    // 检查两个实例是否相同
    std::cout << "obj1 address: " << obj1 << std::endl;
    std::cout << "obj2 address: " << obj2 << std::endl;

    // 调用示例方法
    obj1->showMessage();

    // 手动释放资源
    delete obj1;
    obj1 = nullptr;

    return 0;
}

3、懒汉模式（线程安全）

懒汉模式的线程安全实现通常使用双重校验锁来确保在多线程环境下只有一个实例被创建。这种模式在第一次调用getInstance()方法时才创建唯一的实例，并且确保线程安全。

#include <iostream>
#include <mutex>

class Singleton {
private:
    // 私有静态指针，存储唯一的实例
    static Singleton* instance;

    // 互斥锁，用于线程同步
    static std::mutex mtx;

    // 私有构造函数，防止外部通过 new 创建实例
    Singleton() {
        std::cout << "Singleton instance created." << std::endl;
    }

    // 防止复制构造和赋值操作，确保单例
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    // 提供一个静态方法，返回唯一的实例
    static Singleton* getInstance() {
        if (instance == nullptr) {  // 第一次检查（无锁检查）
            std::lock_guard<std::mutex> lock(mtx);  // 加锁
            if (instance == nullptr) {  // 第二次检查（加锁后检查）
                instance = new Singleton();
            }
        }
        return instance;
    }

    // 释放资源
    ~Singleton() {
        std::cout << "Singleton instance destroyed." << std::endl;
    }

    // 示例方法
    void showMessage() {
        std::cout << "This is a message from the Singleton instance." << std::endl;
    }
};

// 在类外初始化静态成员变量
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;

int main() {
    // 获取单例实例
    Singleton* obj1 = Singleton::getInstance();
    Singleton* obj2 = Singleton::getInstance();

    // 检查两个实例是否相同
    std::cout << "obj1 address: " << obj1 << std::endl;
    std::cout << "obj2 address: " << obj2 << std::endl;

    // 调用示例方法
    obj1->showMessage();

    // 手动释放资源
    delete obj1;
    obj1 = nullptr;

    return 0;
}

同时懒汉模式的线程安全其实有更简单的实现方式

#include <iostream>
#include<vector>
#include<thread>
#include <pthread.h>
class Singleton 
{
private:

    // 私有构造函数，防止外部通过 new 创建实例
    Singleton() 
    {
        std::cout << "Singleton instance created." << std::endl;
    }

    // 防止复制构造和赋值操作，确保单例
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    // 提供一个静态方法，返回唯一的实例
    static Singleton* getInstance() 
    {
        static Singleton instance;
        return &instance;
    }

    // 释放资源
    ~Singleton() 
    {
        std::cout << "Singleton instance destroyed." << std::endl;
    }

    // 示例方法
    void showMessage() 
    {
        std::cout << "This is a message from the Singleton instance." << std::endl;
    }
};

pthread_mutex_t _mtx;

// 线程函数，用于获取单例实例并打印地址
void workerThread() 
{
    Singleton* instance = Singleton::getInstance();
    pthread_mutex_lock(&_mtx);
    std::cout << "Thread " << std::this_thread::get_id() << " instance address: " << instance << std::endl;
    pthread_mutex_unlock(&_mtx);
}

int main() {
    // 创建多个线程，每个线程获取单例实例
    const int numThreads = 5;
    std::vector<std::thread> threads;

    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(workerThread);
    }

    // 等待所有线程完成
    for (auto& thread : threads) {
        thread.join();
    }

    return 0;
}