设计模式之单例模式(C++)

设计模式之单例模式(C++实现)

1. 什么是Singleton?

设计模式中的Singleton,中文翻译是单例模式(也有翻译单件模式),指的是限制一个类只能实例化出一个对象。这种看是奇特使用类的方式在某些情况下是有用的,比如整个系统中只有一个状态管理的类,又比如在Windows中的任务管理器。这些应用场景下只需要一个类的实例,多个实例反而不方便管理,也可能存在某些潜在的冲突,在这些应用中Singleton就可以很好地得到应用。

2. 替代方案

Singleton很明显可以使用一个全局的变量来替换(C++),但是相比于全局变量它有以下的优势:

可以避免引入与全局变量产生冲突
使用单例模式可以使用到延迟加载(lazy allocation and initialization),在没有使用的时候可以节约资源

3. C++中实现

单例模式的一种常用实现如下:

1)考虑到需要只有一个实例,因此常常使用一个静态的变量来表示;
2)为了避免类的使用者new出多个实例,需要将构造函数声明为private
3)但是需要有一种可以得到这个对象的方式,一般使用getInstatnce()这个public的方法来获取这个实例

综合上述介绍,一个简单的实现如下 1.

//定义
class Singleton {
public:
    static Singleton* getInstance();
    void doSomething();
protected:
    Singleton();
private:
    static Singleton* _instance;
};

//实现
Singleton* Singleton::_instance = nullptr;

Singleton* Singleton::getInstance() {
    if (_instance == nullptr) {
        _instance = new Singleton;
    }
    return _instance;
}

void Singleton::doSomething() {
    std::cout << "Doing" << std::endl;
}

这个实现在单线程的环境下工作的很好,但是在多线程环境中可能存在着潜在的危险,考虑到两个线程同时运行到 if (_instance == nullptr),其中一个线程在这个时候被挂起,当另一个线程初始化_instance之后,唤醒挂起的线程,这时候该线程会继续创建一个实例,这与Singleton中单个实例的设计背道而驰了。

4. 解决方案

4.1 简单实现

既然上述的设计并非是线程安全的,那么我们在构造_instance的时候给它加锁不就好了吗?实现如下:

//定义
class Singleton {
public:
    static Singleton* getInstance();
    void doSomething();
protected:
    Singleton();
private:
    static Singleton* _instance;
};

//实现
Singleton* Singleton::_instance = nullptr;
std::mutex mutex;

Singleton* Singleton::getInstance() {
    // 加上mutex使得每次只有一个线程进入
    std::lock_guard<std::mutex> locker(mutex);
    if (_instance == nullptr) {
        _instance = new Singleton;
    }
    return _instance;
}

void Singleton::doSomething() {
    std::cout << "Doing" << std::endl;
}

这样又会引入一个新的令人不爽的地方,线程在getInstance调用时都需要等待其他线程完成访问,这样不利于多线程发挥出它应有的优势。仔细看一下实现,发现实际上真正需要加锁的只有new这一个步骤,这样在初始化完成之后所有的线程就不会在进入到if这个分支中了,于是我们修改为:

Singleton* Singleton::getInstance() {

    if (_instance == nullptr) {
        // 加上mutex使得每次只有一个线程进入
    std::lock_guard<std::mutex> locker(mutex);
        _instance = new Singleton;
    }
    return _instance;
}

但是这样做有一个潜在的危险,当线程A和B都运行到if(_instance == nullptr)之后A线程挂起,B线程运行到加锁,new出对象,之后A线程被唤醒,它也会加锁并再次创建一个对象,于是又会出现两个实例,这与单例模式相悖。

4.2 DCLP方式

既然还是会创建新的对象,那么我们在创建之前再次判断一下不就好了吗,于是引出新的一个概念称为 The Double-Checked Locking Pattern(DCL
P),具体实现如下:

Singleton* Singleton::getInstance() {

    if (_instance == nullptr) {
        // 加上mutex使得每次只有一个线程进入
    std::lock_guard<std::mutex> locker(mutex);
       if (_instance == nullptr)
         _instance = new Singleton;
    }
    return _instance;
}

接着上文的叙述,在A线程加锁之后发现B线程已经将_instance实例化了,于是_instance == nullptr为false,这样A就不会再次new出实例了,完美的解决了问题。

4.3 新的麻烦

使用DCLP就可以解决这个问题吗?事实上在某种程度上可以,但是不同的编译器在执行getInstance这个函数的时候有不同的处理方式,使得使用DCLP并不是一个适用于所有平台和编译器的完美解决方案,具体的细节十分复杂,读者可以参考下面这篇论文
C++ and the Perils of Double-Checked Locking2
文中给出了一个实现真正线程安全的一个实现(需要针对不同的操作系统实现),实现的模式是:

Singleton* Singleton::getInstance() {
    Singleton* tmp = m_instance;
    ...                     // insert memory barrier
    if (tmp == NULL) {
        Lock lock;
        tmp = m_instance;
        if (tmp == NULL) {
            tmp = new Singleton;
            ...             // insert memory barrier
            m_instance = tmp;
        }
    }
    return tmp;
}

4.4 C++11的实现

C++11的一大亮点是引入了跨平台的线程库,通过线程库可以很好的完成上文中提到的问题。

4.4.1 实现方式一

这种实现方式实际上就是对上文中的DCLP的描述,实现代码如下:

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);
    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);
            m_instance.store(tmp, std::memory_order_relaxed);
        }
    }
    return tmp;
}

另外还有其他的实现方式,更多的内容可以参考:Double-Checked Locking Is Fixed In C++11 3

4.4.2 推荐的实现方式

对于singleton的实现方式,在Effective C++中作者实现了

class S
{
    public:
        static S& getInstance()
        {
            static S    instance; 
            return instance;
        }
    private:
        S() {};             

        S(S const&)               = delete;
        void operator=(S const&)  = delete;

};

这种实现方式是线程安全的(C++11),在C++11的规范中有一下描述:

The C++11 standard §6.7.4:

If control enters the declaration concurrently while the variable is being initialized, the concurrent execution shall wait for completion of the initialization.

也就是说C++11保证了静态变量在被初始化的时候强制线程保持同步,这种方式就实现了无锁完美的方案,具体内部的实现是编译器的事情,它可能使用DCLP的方式或者其他的方式完成。但是C++11提到的这个语义保证了单例模式的实现。
更多的内容可以参考4

  1. https://msdn.microsoft.com/en-us/library/ee817670.aspx ↩
  2. http://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf ↩
  3. http://preshing.com/20130930/double-checked-locking-is-fixed-in-cpp11/ ↩
  4. http://stackoverflow.com/questions/1008019/c-singleton-design-pattern ↩

你可能感兴趣的:(设计模式,模式)