单例模式

Posted on Edited on In Comments: Views:

单例模式

在软件系统中，有这样一些特殊的类，必须保证他们在系统中只存在一个实例，才能确保他们的逻辑正确性以及良好的效率。需要绕过常规的构造器，提供一种机制来保证一个类只有一个实例。

下面是几种单例模式的实现：

懒汉非线程安全版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Singleton1 {

private:
    Singleton1() {}
    ~Singleton1() {}
    Singleton1(const Singleton1& a) {}
    Singleton1& operator=(const Singleton1& a) {}
    static Singleton1* instance;

public:

    static Singleton1* getInstance() {
        // 存在资源竞争，虽然可以通过加锁来处理，但对性能影响较大
        // 双重判断的实现不安全，因为指令乱序，可能先复制，再调用构造函数。
        // 单线程没问题
        if (instance == nullptr) {  
            instance = new Singleton1;
        }
        return instance;
    }

};

懒汉线程安全版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Singleton {
    
private:
    Singleton();
    ~Singleton();
    Singleton(Singleton& a);
    Singleton& operator=(Singleton& a);

public:
    static Singleton& getInstance() {
       // 局部static存放在全局数据段，函数返回后变量不会销毁，
       // 而且C++11保证了线程安全性
        static Singleton singleton; 
        return singleton;
    }
};

饿汉线程安全版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Singleton2 {

private:
    Singleton2() {}
    ~Singleton2() {}
    Singleton2(const Singleton2& a) {}
    Singleton2& operator=(const Singleton2& a) {}

    static Singleton2* instance;

public:

    static Singleton2* getInstance() {
        return instance;
    }
};

Singleton2* Singleton2::instance = new Singleton2; // 刚开始就创建