C++ 安全单例模式总结

时间：2025-04-01 20:06:43

前两天，一个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++ 单例一些需要注意的地方：

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

相关文章