Sigleton模式

当有时候需要一个类只能有一个实例化对象的时候，可以考虑单例模式(Sigleton模式)

原理：用一个特殊方法来实例化所需要的对象。

实现方式：将构造函数，赋值，拷贝构造都设为私有，设置一个私有静态对象成员变量，只留出一个静态的接口获取这个唯一的实例。

c++代码如下

 

[cpp] view plain copy

1. #include<iostream>  
2. //#include<mutex>  
3. using namespace std;  
4.   
5. class Singleton  
6. {  
7. private:  
8.     static Singleton *m_pInstance;  
9.     Singleton()   //构造函数是私有的    
10.     {  
11.     }  
12.     //禁用拷贝  
13.     Singleton(const Singleton &);  
14.     Singleton & operator = (const Singleton &);  
15. public:  
16.     static Singleton * GetInstance()  
17.     {  
18.         if (m_pInstance == NULL)  
19.             m_pInstance = new Singleton;  
20.         return m_pInstance;  
21.     }  
22.     void func() { cout << "Singleton里的某个函数" << endl; }  
23. };  
24. Singleton * Singleton::m_pInstance = NULL;  
25. int main()  
26. {  
27.     Singleton::GetInstance()->func();  
28.   
29.     system("pause");  
30. }  

但是这只适用于单线程下的程序，既然单例，就应该使一个对象改变时，其他所有对象都能看到。如果在多线程下，可能两个线程都进行到判断实例是否存在那一步，且此时唯一实例的确是NULL，此时两个线程都会执行new操作，这样将可能引发状态不一致的问题。

 

所以就有了Double-Checked Locking模式，即在判断NULL之后加一个异步的锁，以确保只执行一次

代码如下：

 

[cpp] view plain copy

1. #include<iostream>  
2. #include<mutex>  
3. #include<thread>  
4. using namespace std;  
5.   
6. class Singleton  
7. {  
8. private:  
9.     //禁用拷贝，赋值运算之类  
10.     Singleton(){}  
11.     Singleton(const Singleton &);  
12.     Singleton & operator = (const Singleton &);  
13.     static Singleton *m_pInstance;  
14.     static std::once_flag m_flag;  
15. public:  
16.     static Singleton * GetInstance()  
17.     {  
18.         if (m_pInstance == NULL)  
19.         {  
20.             std::call_once(m_flag, []() {  
21.                 m_pInstance = new Singleton;  
22.                 cout << "实例化完成" << endl;  
23.             });  
24.               
25.         }  
26.         return m_pInstance;  
27.     }  
28.     void func() { cout << "Singleton里的某个函数" << endl; }  
29. };  
30. Singleton * Singleton::m_pInstance = NULL;  
31. std::once_flag Singleton::m_flag;  
32.   
33. int main()  
34. {  
35.   
36.     Singleton::GetInstance()->func();  
37.   
38.     system("pause");  
39. }  

注：c++11中会保证静态成员变量的初始化时线程安全的，所以如果支持c++11，不加锁也没关系。其实我这边用的call_once也是c++11里的。。