正文：

单例模式（Singleton Pattern）是设计模式中最简单但最常用的一种，其核心思想是确保一个类仅有一个实例，并提供一个全局访问点。在C++中，单例模式的实现需要考虑线程安全、资源管理等问题。本文将介绍几种常见的实现方式，并分析它们的优缺点。

1. 单例模式的基本实现

最简单的单例模式可以通过静态成员变量和私有构造函数来实现。以下是一个基础版本：

class Singleton {
private:
    static Singleton* instance;
    Singleton() {} // 私有构造函数
    Singleton(const Singleton&) = delete; // 禁止拷贝构造
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值操作

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};

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

这种实现方式称为懒汉式，即在首次调用 getInstance() 时才创建实例。但它存在线程安全问题：如果多个线程同时调用 getInstance()，可能会导致多次实例化。

2. 线程安全的懒汉式实现

为了解决线程安全问题，可以在 getInstance() 方法上加锁。以下是改进后的代码：

#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mtx;
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

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

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

这种方式通过互斥锁（mutex）确保线程安全，但每次调用 getInstance() 都会加锁，可能影响性能。

3. 双重检查锁定（Double-Checked Locking）

为了减少锁的开销，可以使用双重检查锁定机制：

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mtx;
    Singleton() {}
    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;
    }
};

这种方式仅在实例未初始化时加锁，既保证了线程安全，又减少了性能损耗。

4. 饿汉式单例模式

与懒汉式不同，饿汉式在程序启动时就初始化实例，因此天然线程安全：

class Singleton {
private:
    static Singleton instance;
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton* getInstance() {
        return &instance;
    }
};

Singleton Singleton::instance; // 程序启动时初始化

饿汉式的缺点是可能造成资源浪费，如果实例未被使用，仍会占用内存。

5. C++11 之后的局部静态变量实现

C++11 标准规定，局部静态变量的初始化是线程安全的，因此可以简化实现：

class Singleton {
private:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton& getInstance() {
        static Singleton instance; // 线程安全
        return instance;
    }
};

这种方式简洁高效，是C++11之后推荐的单例实现方式。

总结

单例模式的实现方式多种多样，开发者应根据具体需求选择合适的方法：
- 懒汉式：延迟加载，适合资源敏感场景，但需处理线程安全。
- 饿汉式：启动时加载，线程安全，但可能浪费资源。
- C++11局部静态变量：简洁高效，推荐使用。

掌握单例模式的核心思想，能帮助开发者设计更健壮的系统架构。