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

【GeekBand】C++设计模式笔记12_Singleton_单件模式

article 2024/11/19 11:14:38

1. “对象性能” 模式

面向对象很好地解决了 “抽象” 的问题，但是必不可免地要付出一定的代价。对于通常情况来讲，面向对象的成本大都可以忽略不计。但是某些情况，面向对象所带来的成本必须谨慎处理。
典型模式
- Singleton
- Flyweight

2. Singleton 单件模式

2.1 动机（Motivation）

在软件系统中，经常有这样一些特殊的类，必须保证它们在系统中只存在一个实例，才能确保它们的逻辑正确性以及良好的效率。
如何绕过常规的构造器，提供一种机制来保证一个类只有一个实例？
这应该是类设计者的责任，而不是使用者的责任。

2.2 模式定义

保证一个类仅有一个实例，并提供一个该实例的全局访问点。
——《设计模式》GoF

2.3 实例代码

class Singleton {
private:
	// 将构造函数、拷贝构造函数设置成 private，不允许用户创建实例
    Singleton();
    Singleton(const Singleton& other);
    
public:
	// 提供实例的全局访问点
    static Singleton* getInstance();

private:
	// static 成员，唯一的实例
    static Singleton* m_instance;
};

// static 成员初始化
Singleton* Singleton::m_instance = nullptr;

/*
线程非安全版本，多线程环境下有可能创建出多个实例，
当线程A在执行完(1)、执行(2)之前，线程B抢到时间片，开始执行(1)，这样线程A和B都可以创建出实例，
所以在多线程环境中需要加锁。
*/ 
Singleton* Singleton::getInstance() {
    if (m_instance == nullptr) {		// (1)
        m_instance = new Singleton();	// (2)
    }
    return m_instance;
}

/*
线程安全版本，但锁的代价过高，
因为锁的粒度粗，进入函数后立马加锁，整个函数过程都持有锁，
一般m_instance是只读的，当m_instance创建完成后，各线程可以直接获取该实例，
该代码既有问题：当线程A持有锁时，线程B无法获取m_instance，必须等待线程A释放锁。
*/
Singleton* Singleton::getInstance() {
    Lock lock;
    if (m_instance == nullptr) {
        m_instance = new Singleton();
    }
    return m_instance;
}

/*
双检查锁，但由于内存读写reorder不安全
reorder含义：编译器可能改变对象构造的顺序
常规对象构造分为3个步骤：a.分配空间；b.调用构造函数完成对象初始化；c.返回对象的指针；但编译器有时会改变这3个顺序，变成a.c.b。
这样代码就会出现问题：当m_instance未初始化时，线程A需要对m_instance进行实例化，若当线程A完成步骤a和c，而未完成b时，线程B调用该函数，由于此刻 m_instance != nullptr，会直接返回m_instance，但该实例尚未完成初始化，直接使用该实例会产生未定义行为。
(2)处的二次检查必不可少：当AB两个线程都通过(1)后开始抢锁，假设A抢到了锁，A对m_instance进行实例化，当线程A释放锁线程B获得锁后，如果没有(2)处的检查，线程B将再次对m_instance初始化，不符合单例模式设计原则。
*/
Singleton* Singleton::getInstance() { 
    if (m_instance == nullptr) {	// (1)
        Lock lock;
        if (m_instance == nullptr) {		// (2)，这里的二次检查必不可少
            m_instance = new Singleton();	// (3)
        }
    }
    return m_instance;
}

// C++ 11版本之后的跨平台实现 (volatile)
std::atomic<Singleton*> Singleton::m_instance;
std::mutex Singleton::m_mutex;

Singleton* Singleton::getInstance() {
    Singleton* tmp = m_instance.load(std::memory_order_relaxed);
    std::atomic_thread_fence(std::memory_order_acquire);	// 获取内存fence
    if (tmp == nullptr) {
        std::lock_guard<std::mutex> lock(m_mutex);
        tmp = m_instance.load(std::memory_order_relaxed);
        if (tmp == nullptr) {
            tmp = new Singleton;
            std::atomic_thread_fence(std::memory_order_release);	// 释放内存fence
            m_instance.store(tmp, std::memory_order_relaxed);
        }
    }
    return tmp;
}