当前位置：首页 > article >正文

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

article 2025/1/13 5:03:16

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

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 及以上标准支持。

查看全文

http://www.kler.cn/a/500310.html