线程安全单例模式(C++)

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[-]

1. 线程安全单例模式C
   1. 饿汉模式
   2. 懒汉模式

线程安全单例模式(C++)

---

饿汉模式

饿汉模式：即无论是否调用该类的实例，在程序开始时就会产生一个该类的实例，并在以后仅返回此实例。

由静态初始化实例保证其线程安全性，why？因为静态实例初始化在程序开始时进入主函数之前就由主线程以单线程方式完成了初始化，不必担心多线程问题。

故在性能需求较高时，应使用这种模式，避免频繁的锁争夺。

#include<iostream>
using namespace std;

class Singleton
{
    public:
        static Singleton *GetInstance()
        {
            return m_pInstance;
        }

    private:
        static Singleton *m_pInstance;
        Singleton() { cout << "Singleton()" << endl; };
        ~Singleton() { cout << "~Singleton()" << endl; };

        class Garbo     /* Garbo意为垃圾工人，任务是在 Singleton 实例生命周期结束后(即进程即将结束）回收该实例 */
        {
            public:
                ~Garbo()
                {
                    if(Singleton::m_pInstance)
                        delete m_pInstance;
                }
        };
        static Garbo garbo;
};

Singleton::Garbo Singleton::garbo;      /* 一定要初始化，否则程序结束时不会调用~Garbo() */
Singleton *Singleton::m_pInstance = new Singleton;  /* main函数之前就生成一个实例 */

int main(void)
{
    Singleton *p1 = Singleton::GetInstance();
    Singleton *p2 = Singleton::GetInstance();
    if(p1 == p2)
    {
        cout << "p1 == p2" << endl;
    }
    return 0;
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

$ g++ Singleton.cpp -o Singleton
$ ./Singleton
Singleton()
p1 == p2
~Singleton()
   
   
1
2
3
4
5
   
   
1
2
3
4
5

懒汉模式

懒汉模式：即第一次调用该类实例的时候才产生一个新的该类实例，并在以后仅返回此实例。

需要用锁，来保证其线程安全性：原因：多个线程可能进入判断是否已经存在实例的if语句，从而非线程安全.

使用double-check来保证线程安全.但是如果处理大量数据时，该锁才成为严重的性能瓶颈。

#include<iostream>
#include<pthread.h>
using namespace std;

pthread_mutex_t mutex;

class Singleton
{
    public:
        static Singleton *GetInstance()
        {
            if(NULL == m_pInstance)
            {
                pthread_mutex_lock(&mutex);
                if(m_pInstance == NULL)
                    m_pInstance = new Singleton;
                pthread_mutex_unlock(&mutex);
            }
            return m_pInstance;
        }

    private:
        static Singleton *m_pInstance;
        Singleton() { cout << "Singleton()" << endl; }
        ~Singleton() { cout << "~Singleton()" << endl; }

        class Garbo
        {
            public:
                ~Garbo()
                {
                    if(m_pInstance)
                        delete m_pInstance;
                }
        };
        static Garbo garbo;
};
Singleton::Garbo Singleton::garbo;          /* 静态类成员初始化 */
Singleton *Singleton::m_pInstance = NULL;   /* 静态类成员初始化 */
int main(void)
{
    pthread_mutex_init(&mutex, NULL);

    Singleton *p1 = Singleton::GetInstance();
    Singleton *p2 = Singleton::GetInstance();
    if(p1 == p2)
        cout << "p1 == p2" << endl;

    pthread_mutex_destroy(&mutex);
    return 0;
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

$ g++ Singleton.cpp -o Singleton
$ ./Singleton
Singleton()
p1 == p2
~Singleton()