C++单例模式安全实现方法解析

单例模式通过局部静态变量实现线程安全且生命周期可控，C++11起推荐此法，代码简洁高效。

单例模式确保一个类只有一个实例，并提供全局访问点。在C++中实现线程安全、生命周期可控的单例模式，需要考虑构造安全、多线程竞争和资源释放等问题。

懒汉模式 + 双重检查锁定（C++11及以上推荐）

这种写法延迟初始化，同时利用C++11的静态局部变量特性保证线程安全。

代码示例：

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance; // C++11 线程安全
        return instance;
    }
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
private:
Singleton() = default;
~Singleton() = default;
};

手动加锁实现（适用于旧标准）

如果使用C++98或需要更精细控制，可用互斥锁配合双重检查。

说明：第一次检查避免每次加锁，第二次检查确保唯一性。

#include <mutex>
class Singleton {
private:
static Singleton* instance;
static std::mutex mtx;
Singleton() = default;
public:
static Singleton* getInstance() {
if (instance == nullptr) { // 第一次检查
std::lock_guard<std::mutex> lock(mtx);
if (instance == nullptr) { // 第二次检查
instance = new Singleton();
}
}
return instance;
}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
};
// 静态成员定义
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;

饿汉模式（进程启动即创建）

在程序加载时就创建实例，天然避免多线程问题。

适合能接受提前初始化的场景，无延迟但可能浪费资源。

class Singleton {
private:
    static Singleton instance;
Singleton() = default;
public:
static Singleton& getInstance() {
return instance;
}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
};
// 全局初始化
Singleton Singleton::instance;

智能指针 + 自定义删除器（防止析构问题）

若使用动态分配并希望自动回收，可结合std::shared_ptr和自定义删除器。

#include <memory>
#include <mutex>
class Singleton {
private:
static std::shared_ptr<Singleton> instance;
static std::mutex mtx;
Singleton() = default;
public:
static std::shared_ptr<Singleton> getInstance() {
if (!instance) {
std::lock_guard<std::mutex> lock(mtx);
if (!instance) {
instance = std::shared_ptr<Singleton>(new Singleton(), [](Singleton* p) {
// 自定义删除器，防止多次delete
delete p;
});
}
}
return instance;
}
};
std::shared_ptr<Singleton> Singleton::instance = nullptr;

基本上就这些。现代C++推荐使用局部静态变量方式，简单又安全。注意禁用拷贝构造和赋值操作，避免意外复制。不复杂但容易忽略细节。