在某些应用环境下面，一个类只允许有一个实例，这就是著名的单例模式。单例模式分为懒汉模式，跟饿汉模式两种。
首先给出饿汉模式的实现
正解：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
template <class T>class singleton{protected: singleton(){};private: singleton(const singleton&){};//禁止拷贝 singleton& operator=(const singleton&){};//禁止赋值 static T* m_instance;public: static T* GetInstance();}; template <class T>T* singleton<T>::GetInstance(){ return m_instance;} template <class T> |
在实例化m_instance 变量时，直接调用类的构造函数。顾名思义，在还未使用变量时，已经对m_instance进行赋值，就像很饥饿的感觉。这种模式，在多线程环境下肯定是线程安全的，因为不存在多线程实例化的问题。
下面来看懒汉模式
|
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
|
template <class T>class singleton{protected: singleton(){};private: singleton(const singleton&){}; singleton& operator=(const singleton&){}; static T* m_instance;public: static T* GetInstance();}; template <class T>T* singleton<T>::GetInstance(){ if( m_instance == NULL) { m_instance = new T(); } return m_instance;} template <class T>T* singleton<T>::m_instance = NULL; |
懒汉模式下，在定义m_instance变量时先等于NULL，在调用GetInstance()方法时，在判断是否要赋值。这种模式，并非是线程安全的，因为多个线程同时调用GetInstance()方法，就可能导致有产生多个实例。要实现线程安全，就必须加锁。
下面给出改进之后的代码
|
1
|
template <class T><br>class singleton<br>{<br>protected:<br> singleton(){};<br>private:<br> singleton(const singleton&){};<br> singleton& operator=(const singleton&){};<br> static T* m_instance;<br> static pthread_mutex_t mutex;<br>public:<br> static T* GetInstance();<br>};<br> <br> <br>template <class T><br>T* singleton<T>::GetInstance()<br>{<br> pthread_mutex_lock(&mutex);<br> if( m_instance == NULL)<br> { <br> m_instance = new T();<br> }<br> pthread_mutex_unlock(&mutex);<br> return m_instance;<br>}<br> <br> <br>template <class T><br>pthread_mutex_t singleton<T>::mutex = PTHREAD_MUTEX_INITIALIZER;<br> <br>template <class T><br>T* singleton<T>::m_instance = NULL;<br> |
这一切看起来都很完美，但是程序猿是一种天生就不知道满足的动物。他们发现GetInstance()方法，每次进来都要加锁，会影响效率。然而这并不是必须的，于是又对GetInstance()方法进行改进
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
template <class T>T* singleton<T>::GetInstance(){ if( m_instance == NULL) { pthread_mutex_lock(&mutex); if( m_instance == NULL) { m_instance = new T(); } pthread_mutex_unlock(&mutex); } return m_instance;} |
这也就是所谓的“双检锁”机制。但是有人质疑这种实现还是有问题，在执行 m_instance = new T()时，可能 类T还没有初始化完成，m_instance 就已经有值了。这样会导致另外一个调用GetInstance()方法的线程，获取到还未初始化完成的m_instance 指针，如果去使用它，会有意料不到的后果。其实，解决方法也很简单，用一个局部变量过渡下即可：
正解：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
template <class T>T* singleton<T>::GetInstance(){ if( m_instance == NULL) { pthread_mutex_lock(&mutex); if( m_instance == NULL) { T* ptmp = new T(); m_instance = ptmp; } pthread_mutex_unlock(&mutex); } return m_instance;} |
到这里在懒汉模式下，也就可以保证线程安全了。
然而，在linux下面还有另一种实现。linux提供了一个叫pthread_once()的函数，它保证在一个进程中，某个函数只被执行一次。下面是使用pthread_once实现的线程安全的懒汉单例模式
|
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
|
template <class T>class singleton{protected: singleton(){};private: singleton(const singleton&){}; singleton& operator=(const singleton&){}; static T* m_instance; static pthread_once_t m_once;public: static void Init(); static T* GetInstance();}; template <class T>void singleton<T>::Init(){ m_instance = new T();} template <class T>T* singleton<T>::GetInstance(){ pthread_once(&m_once,Init); return m_instance;} template <class T>pthread_once_t singleton<T>::m_once = PTHREAD_ONCE_INIT; template <class T>T* singleton<T>::m_instance = NULL; |
上面的单例类使用了模板，对每一种类型的变量都能实例化出唯一的一个实例。
例如要实例化一个int类型
|
1
|
int *p = singleton<int>::GetInstance() |
例如要实例化一个string类型
|
1
|
string *p = singleton<string>::GetInstance() |
在上面的实现中，在实例化对象时，调用GetInstance()函数时都没有传递参数，这是犹豫不同的对象其初始化时参数个数都不一样。如果要支持不同类型的对象带参数初始化，则需要重载GetInstance函数。然而在c++11中，已经支持了可变参数函数。这里给出一个简单的例子
|
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
|
#ifndef _SINGLETON_H_#define _SINGLETON_H_ template <class T>class singleton{protected: singleton(){};private: singleton(const singleton&){}; singleton& operator=(const singleton&){}; static T* m_instance;public: template <typename... Args> static T* GetInstance(Args&&... args) { if(m_instance == NULL) m_instance = new T(std::forward<Args>(args)...); return m_instance; } static void DestroyInstance() { if(m_instance ) delete m_instance; m_instance = NULL; }}; template <class T>T* singleton<T>::m_instance = NULL; #endif |
测试函数
|
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
|
#include <iostream>#include <string>#include "singleton.h" using namespace std;struct A{ A(int a ,int b):_a(a),_b(b) {} int _a; int _b;}; int main(){ int *p1 = singleton<int>::GetInstance(5); int *p2 = singleton<int>::GetInstance(10); cout << *p1 << " " << *p2 <<endl; string *p3 = singleton<string>::GetInstance("aa"); string *p4 = singleton<string>::GetInstance("bb"); cout << *p3 << " " << *p4 <<endl; A *p5 = singleton<A>::GetInstance(1,2); A *p6 = singleton<A>::GetInstance(4,5); cout << p5->_a << " " << p6->_a<<endl; return 0;} |
运行结果如下
以上所述是小编给大家介绍的C++实现线程安全的单例模式详解整合，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持！
原文链接：https://blog.csdn.net/sinat_22991367/article/details/85922380
