正文

掌握C++单例模式：轻松实现全局唯一实例的代码实践

/0 浏览量
1014

在软件开发中，单例模式是一种常用的设计模式，它确保一个类只有一个实例，并提供一个全局访问点。C++作为一种广泛使用的编程语言，同样支持单例模式。本文将详细讲解如何使用C++实现单例模式，并通过代码实例帮助读者轻松掌握这一技巧。

单例模式的概念

单例模式的主要目的是限制一个类只有一个实例，并提供一个访问它的全局方法。在多线程环境下，单例模式还需要考虑线程安全问题。下面我们来一步步实现一个线程安全的单例模式。

简单单例实现

首先，我们来实现一个简单的单例模式。以下是一个不包含线程安全的单例模式示例：

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;
    }
    void doSomething() {
        // 业务逻辑
    }
};

Singleton* Singleton::instance = nullptr;

在这个例子中，Singleton 类的构造函数是私有的，外部无法直接创建其实例。getInstance 方法用于获取类的唯一实例。当第一次调用 getInstance 方法时，会创建 Singleton 类的一个实例，并将其存储在静态指针 instance 中。之后的调用都会返回这个唯一的实例。

线程安全的单例实现

在实际应用中，我们的程序可能运行在多线程环境中。为了保证线程安全，我们需要对上述简单单例实现进行改进。以下是几种常见的线程安全单例实现方法：

饿汉式

饿汉式是在类加载时就完成了实例化，保证了线程安全，但可能造成资源浪费。

class Singleton {
private:
    static Singleton instance;
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton& getInstance() {
        return instance;
    }
    void doSomething() {
        // 业务逻辑
    }
};

Singleton Singleton::instance;

懒汉式

懒汉式是在真正需要使用实例时才进行实例化，减少了资源浪费，但需要考虑线程安全。

#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex;
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mutex);
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance;
    }
    void doSomething() {
        // 业务逻辑
    }
};

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

双重检查锁定

双重检查锁定（Double-Checked Locking）是懒汉式的一种改进，它避免了在实例已经创建的情况下进行不必要的加锁操作。

#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mutex;
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mutex);
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance;
    }
    void doSomething() {
        // 业务逻辑
    }
};

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

C++11的线程安全单例

C++11提供了原子操作和智能指针等新特性，我们可以利用这些特性简化线程安全单例的实现。

#include <memory>
#include <atomic>

class Singleton {
private:
    static std::atomic<Singleton*> instance;
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    static Singleton* getInstance() {
        Singleton* temp = instance.load(std::memory_order_acquire);
        if (temp == nullptr) {
            std::lock_guard<std::mutex> lock(mutex);
            temp = instance.load(std::memory_order_relaxed);
            if (temp == nullptr) {
                temp = new Singleton();
                instance.store(temp, std::memory_order_release);
            }
        }
        return temp;
    }
    void doSomething() {
        // 业务逻辑
    }
};

std::atomic<Singleton*> Singleton::instance(nullptr);
std::mutex Singleton::mutex;

在上述代码中，我们使用了 std::atomic 来保证实例的唯一性和线程安全。

总结

通过本文的学习，我们了解了C++单例模式的概念、实现方法和线程安全问题。在实际开发中，我们可以根据具体需求选择合适的单例实现方式。希望本文能帮助你轻松掌握C++单例模式。

-- 展开阅读全文 --