单例模式-如何保证全局唯一性？

以下是几种实现单例模式并保证全局唯一性的方法：

1. 饿汉式单例模式

class Singleton {
private:// 私有构造函数，防止外部创建对象Singleton() {}// 静态成员变量，存储单例对象static Singleton instance;
public:// 公有静态成员函数，用于获取单例对象static Singleton& getInstance() {return instance;}
};// 静态成员变量的初始化，在程序启动时创建单例对象
Singleton Singleton::instance;

解释：

• 构造函数私有化：将 Singleton 类的构造函数声明为 private，确保外部无法直接创建该类的对象。
• 静态成员变量：使用 static Singleton instance 存储单例对象。
• 静态成员函数：通过 static Singleton& getInstance() 提供获取单例对象的接口。
• 全局初始化：在程序启动时，Singleton::instance 就会被创建，因为它是静态成员，且在类外进行了定义和初始化。这保证了在程序运行的任何时刻，getInstance() 都能返回同一个对象。

2. 懒汉式单例模式（线程不安全）

class Singleton {
private:// 私有构造函数，防止外部创建对象Singleton() {}// 静态成员变量，存储单例对象static Singleton* instance;
public:// 公有静态成员函数，用于获取单例对象static Singleton* getInstance() {if (instance == nullptr) {instance = new Singleton();}return instance;}
};// 静态成员变量的初始化，初始化为 nullptr
Singleton* Singleton::instance = nullptr;

解释：

• 构造函数私有化：与饿汉式相同，将构造函数设为 private。
• 静态指针成员变量：使用 static Singleton* instance 存储单例对象的指针，初始化为 nullptr。
• 静态成员函数：getInstance() 函数在首次调用时检查 instance 是否为 nullptr，若为 nullptr 则创建对象，后续调用都将返回同一个对象。
• 线程不安全：这种方式在多线程环境下存在问题，多个线程可能同时检查到 instance 为 nullptr，并同时创建对象，导致多个实例的出现。

3. 懒汉式单例模式（线程安全，使用互斥锁）

#include <mutex>class Singleton {
private:// 私有构造函数，防止外部创建对象Singleton() {}// 静态成员变量，存储单例对象static Singleton* instance;// 互斥锁，用于线程同步static std::mutex mtx;
public:// 公有静态成员函数，用于获取单例对象static Singleton* getInstance() {std::unique_lock<std::mutex> lock(mtx);if (instance == nullptr) {instance = new Singleton();}return instance;}
};// 静态成员变量的初始化，初始化为 nullptr
Singleton* Singleton::instance = nullptr;
// 静态成员变量的初始化，创建互斥锁
std::mutex Singleton::mtx;

解释：

• 构造函数私有化：确保外部无法直接创建对象。
• 静态指针成员变量：存储单例对象的指针，初始化为 nullptr。
• 互斥锁：使用 std::mutex mtx 进行线程同步。
• 静态成员函数：在 getInstance() 中，使用 std::unique_lock 获取互斥锁，确保同一时刻只有一个线程可以创建单例对象。
• 性能问题：这种方式每次调用 getInstance() 都需要加锁，即使 instance 已经创建，会影响性能。

4. 懒汉式单例模式（线程安全，双重检查锁定）

#include <mutex>class Singleton {
private:// 私有构造函数，防止外部创建对象Singleton() {}// 静态成员变量，存储单例对象static Singleton* instance;// 互斥锁，用于线程同步static std::mutex mtx;
public:// 公有静态成员函数，用于获取单例对象static Singleton* getInstance() {if (instance == nullptr) {std::unique_lock<std::mutex> lock(mtx);if (instance == nullptr) {instance = new Singleton();}}return instance;}
};// 静态成员变量的初始化，初始化为 nullptr
Singleton* Singleton::instance = nullptr;
// 静态成员变量的初始化，创建互斥锁
std::mutex Singleton::mtx;

 解释：

• 构造函数私有化：防止外部创建对象。
• 静态指针成员变量：存储单例对象指针，初始化为 nullptr。
• 互斥锁：用于线程同步。
• 静态成员函数：使用双重检查锁定，第一次检查 instance 是否为 nullptr 是无锁的，若为 nullptr 则加锁再次检查并创建对象，避免了每次调用 getInstance() 都加锁的性能问题。
• 潜在问题：在某些编译器和处理器架构下，由于指令重排，可能导致 instance 已经分配内存但未完成构造函数调用，导致其他线程访问到未完全初始化的对象。

5. 懒汉式单例模式（线程安全，C++11 及以上） 

#include <memory>
#include <mutex>class Singleton {
private:// 私有构造函数，防止外部创建对象Singleton() {}
public:// 公有静态成员函数，用于获取单例对象static Singleton& getInstance() {static std::once_flag flag;std::call_once(flag, []() {instance.reset(new Singleton());});return *instance.get();}
private:// 静态成员变量，存储单例对象static std::unique_ptr<Singleton> instance;
};// 静态成员变量的初始化，使用智能指针存储单例对象
std::unique_ptr<Singleton> Singleton::instance;

 解释：

• 构造函数私有化：防止外部创建对象。
• 静态成员函数：使用 std::once_flag 和 std::call_once 保证单例对象只被创建一次。
• 智能指针：使用 std::unique_ptr<Singleton> instance 存储单例对象，避免了内存管理问题。
• C++11 特性：std::call_once 是 C++11 引入的，确保 instance 只会被调用一次，且是线程安全的，解决了双重检查锁定的指令重排问题。

6、总结

通过以上几种方式，可以实现单例模式并保证全局唯一性。在实际应用中，推荐使用 C++11 及以上的 std::call_once 和 std::unique_ptr 实现，它提供了简洁、安全和高效的单例模式实现方式。

上述几种实现方式都旨在保证单例模式的全局唯一性，但各有优缺点，你可以根据实际需求和开发环境选择合适的实现方式。**代码解释**：
- **饿汉式单例模式**：- 优点：实现简单，在程序启动时就创建单例对象，保证了线程安全和全局唯一性。- 缺点：可能会造成资源浪费，因为单例对象在程序开始时就创建，无论是否使用。- **懒汉式单例模式（线程不安全）**：- 优点：单例对象在首次使用时创建，避免了资源浪费。- 缺点：在多线程环境下无法保证单例对象的唯一性，会出现多个实例。- **懒汉式单例模式（线程安全，使用互斥锁）**：- 优点：使用互斥锁保证了多线程环境下的单例对象唯一性。- 缺点：性能开销大，每次调用 `getInstance()` 都要加锁，即使单例对象已经创建。- **懒汉式单例模式（双重检查锁定）**：- 优点：在多线程环境下相对高效，避免了每次调用都加锁。- 缺点：存在指令重排的潜在风险，可能导致获取到未完全初始化的对象。- **懒汉式单例模式（线程安全，C++11及以上）**：- 优点：结合了 `std::call_once` 和 `std::unique_ptr`，既保证了线程安全，又避免了指令重排问题，是现代 C++ 推荐的实现方式。- 缺点：需要 C++11 及以上标准支持。