C++ 安全单例模式总结

前两天，一个C++ 的单例实现又掉坑里了。做好一个安全的单例模式可并不简单。这里总结一下C++ 的几个单例实现方案。

1. 函数静态变量法

利用单例函数的静态变量，实现单例构造。代码如下：

class StaticVarSingleTon {
public:
    static StaticVarSingleTon *GetInstance() {
        static StaticVarSingleTon s_instance;
        return &s_instance;
    }

private:
    StaticVarSingleTon() {}
    virtual ~StaticVarSingleTon() {};
    StaticVarSingleTon(const StaticVarSingleTon &);
    StaticVarSingleTon& operator=(const StaticVarSingleTon& other);
};

这里利用函数的静态变量，只会存在一份的特性，来实现单例的构造。代码直接明了。

优点

• 代码简单，直接明了
• 还是个懒加载模式

缺点

• 静态变量的构造，不是线程安全的。

2. 类静态成员变量

利用类的静态变量的全局唯一性，来实现单例的构造。代码如下：

//
//  StaticMemberSingleton.h
//

#ifndef StaticMemberSingleton_h
#define StaticMemberSingleton_h

class StaticMemberSingleTon {
public:
    static StaticMemberSingleTon *GetInstance() {
        return &s_instance;
    }

private:
    StaticMemberSingleTon() {}
    virtual ~StaticMemberSingleTon() {};
    StaticMemberSingleTon(const StaticMemberSingleTon &);
    StaticMemberSingleTon& operator=(const StaticMemberSingleTon& other);

private:
    static StaticMemberSingleTon s_instance;
};

#endif /* StaticMemberSingleton_h*/

//
//  StaticMemberSingleton.cpp
//

#include "StaticMemberSingleton.h"

StaticMemberSingleTon StaticMemberSingleTon::s_instance;

优点

• 这里的StaticMemberSingleTon StaticMemberSingleTon::s_instance 是一个全局变量。只会出现一份。
• 全局变量的初始化，在main 函数执行之前完成。可以保证线程安全。

缺点

• 当有另外一个 StaticMemberSingletonB，在构造函数中依赖 StaticMemberSingletonA 的单例对象时，可能出现StaticMemberSingletonA 的单例对象还没有初始化的问题。

让我们用代码来验证一下，我们构造两个单例：StaticMemberSingletonA， StaticMemberSingletonB.

StaticMemberSingletonA 的构造函数，调用StaticMemberSingletonB 的方法；

StaticMemberSingletonB 的构造函数，调用StaticMemberSingletonA 的方法。

代码如下。

//
//  StaticMemberSingletonA.h
//

#ifndef StaticMemberSingletonA_h
#define StaticMemberSingletonA_h

#include <stdio.h>

class StaticMemberSingleTonA {
public:
    static StaticMemberSingleTonA *GetInstance() {
        return &s_instance;
    }

    void showValue() {
        printf("SingleTonA value %d\n", value);
    }

private:
    StaticMemberSingleTonA();

    virtual ~StaticMemberSingleTonA() {};
    StaticMemberSingleTonA(const StaticMemberSingleTonA &);
    StaticMemberSingleTonA& operator=(const StaticMemberSingleTonA& other);

private:
    static StaticMemberSingleTonA s_instance;

private:
    int value = 0;
};

#endif /* StaticMemberSingletonA_h*/

//
//  StaticMemberSingletonA.cpp
//

#include "StaticMemberSingletonA.h"
#include "StaticMemberSingletonB.h"

StaticMemberSingleTonA StaticMemberSingleTonA::s_instance;

StaticMemberSingleTonA::StaticMemberSingleTonA() {
    value = 1;

    StaticMemberSingleTonB::GetInstance()->showValue();
}

//
//  StaticMemberSingletonB.h
//

#ifndef StaticMemberSingletonB_h
#define StaticMemberSingletonB_h

#include <stdio.h>

class StaticMemberSingleTonB {
public:
    static StaticMemberSingleTonB *GetInstance() {
        return &s_instance;
    }

    void showValue() {
        printf("SingleTonB value %d\n", value);
    }

private:
    StaticMemberSingleTonB();

    virtual ~StaticMemberSingleTonB() {};
    StaticMemberSingleTonB(const StaticMemberSingleTonB &);
    StaticMemberSingleTonB& operator=(const StaticMemberSingleTonB& other);

private:
    static StaticMemberSingleTonB s_instance;

private:
    int value = 0;
};

#endif /* StaticMemberSingletonB_h*/

//
//  StaticMemberSingletonB.cpp
//

#include "StaticMemberSingletonB.h"
#include "StaticMemberSingletonA.h"

StaticMemberSingleTonB StaticMemberSingleTonB::s_instance;

StaticMemberSingleTonB::StaticMemberSingleTonB() {
    value = 2;
    StaticMemberSingleTonA::GetInstance()->showValue();
}

//
//  main.cpp
//

#include <stdio.h>
#include "StaticMemberSingletonA.h"

int main(int argc, const char * argv[]) {
    StaticMemberSingleTonA::GetInstance();
    return 0;
}

执行一下，结果如下：

SingleTonA value 0
SingleTonB value 2
Program ended with exit code: 0

3. 线程安全的单例方法

一般常见的C++ 线程安全的单例实现代码，如下：

//
//  SafeSingleton.h
//

#ifndef SafeSingleton_h
#define SafeSingleton_h

#include "Mutex.h"

class SafeSingleton {
public:
    static SafeSingleton *GetInstance();

private:
    SafeSingleton() {};
    virtual ~SafeSingleton() {};
    SafeSingleton(const SafeSingleton &);
    SafeSingleton& operator=(const SafeSingleton& other);

private:
    static SafeSingleton *s_instance;
    static Mutex          s_insMutex;
};

#endif /* SafeSingleton_h*/

//
//  SafeSingleton.cpp
//

#include "SafeSingleton.h"

SafeSingleton *SafeSingleton::s_instance;
Mutex          SafeSingleton::s_insMutex;

SafeSingleton *SafeSingleton::GetInstance() {
    if (s_instance == nullptr) {
        s_insMutex.lock();
        if (s_instance == nullptr) {
            s_instance = new SafeSingleton();
        }
        s_insMutex.unlock();
    }
    return s_instance;
}

注意：

• 第一次判断 s_instance 非空，是为了提升性能，避免无谓的加锁。
• 获得锁后，必须再次判断 s_instance 非空，避免多线程下二次创建。
• 另外，由于所有实例的构造，都在main函数之后执行了。而锁对象是全局变量，在main 之前就已经完成初始化了，不会出现方案2 中的对象未初始化现象。
• 当然，如果真这儿做了，会出现死锁。

4. 还未结束

我们在C++ 层实现了一个网络状态监控模块，这个模块给iOS 业务层使用。当时业务层实现了自己的一个网络状态模块。大致代码如下所示：

@implementation IOSNetworkState

+ (void)load {
    [IOSNetworkState sharedInstance];
}

+ (instancetype)sharedInstance {
    static IOSNetworkState *instance;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[IOSNetworkState alloc] init];
    });
    return instance;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        Network::NetworkMonitor::GetInstance()->DoXXX();
    }
    return self;
}

然后就悲剧了，APP 起来就crash。crash 的位置是，执行 Network::NetworkMonitor::GetInstance() 方法时，加锁操作crash。原因是Mutex 对象未初始化。

原来，OC 类的 +(void)load 方法，其执行时期是类的加载期。比全局对象（就是我们的Mutex）的初始化要早。当然这个时候，main 函数更加没有得到执行。

自然我们这时候，执行加锁操作就会引发异常了。

5. 总结

简单总结一下，使用c++ 单例一些需要注意的地方：

• 一：使用线程安全的单例方法。
• 二：尽量避免在单例类的构造方法中，使用其他的单例对象。
• 三：不要在类的加载期方法中，使用其他单例对象。其实，在类加载期方法中，不应该涉及业务处理。