单例模式具体事例，用到window下多线程,线程锁,模板等功能

1. 转自：http://blog.chinaunix.net/uid-25808509-id-3026355.html

1. #include <iostream>
   
2. #include <cstdio>
   
3. #include <Windows.h>
   
4. 
   
5. class TestClass
   
6. {
   
7. public:
   
8.     TestClass()
   
9.         :x(0)
   
10.     {
    
11.         ::Sleep(1000);
    
12.         num++;
    
13.     }
    
14.     ~TestClass(){}
    
15.     void Inc() { x++;}
    
16.     void Show()
    
17.     {
    
18.         char result[20] ={0};
    
19.         sprintf(result, "x = %d\n", x);
    
20.         printf(result);
    
21.     }
    
22. 
    
23. public:
    
24.     static int num;
    
25. 
    
26. private:
    
27.     int x;
    
28.     
    
29. };
    
30. 
    
31. int TestClass::num = 0;
    
32. 
    
33. class CLock
    
34. {
    
35. public:
    
36.     CLock()
    
37.     {
    
38.         ::InitializeCriticalSection(&m_Section);
    
39.     }
    
40.     ~CLock()
    
41.     {
    
42.         ::DeleteCriticalSection(&m_Section);
    
43.     }
    
44. 
    
45.     void Lock()
    
46.     {
    
47.         ::EnterCriticalSection(&m_Section);
    
48.     }
    
49. 
    
50.     void UnLock()
    
51.     {
    
52.         ::LeaveCriticalSection(&m_Section);
    
53.     }
    
54. 
    
55. private:
    
56.     CRITICAL_SECTION m_Section;
    
57. };
    
58. 
    
59. template <typename T>
    
60. class Singleton
    
61. {
    
62. public:
    
63.     static T* getPointer()
    
64.     {
    
65.         if(m_instance == NULL)
    
66.         {
    
67.             m_Lock.Lock();
    
68. 
    
69.             if(m_instance == NULL)
    
70.             {
    
71. 
    
72.                 T* instance = new T();
    
73. 
    
74.                 m_instance = reinterpret_cast<void*>(instance);
    
75.             }
    
76. 
    
77.             m_Lock.UnLock();
    
78.         }
    
79. 
    
80.         return reinterpret_cast<T*>(m_instance);
    
81.         
    
82.     }
    
83. 
    
84.     static T & instance()
    
85.     {
    
86.         return *getPointer();
    
87.     }
    
88. 
    
89.     static void release()
    
90.     {
    
91.         if(m_instance)
    
92.         {
    
93.             delete m_instance;
    
94.             m_instance = NULL;
    
95.         }
    
96.     }
    
97. 
    
98. private:
    
99.     static void* m_instance;
    
100.     static CLock m_Lock;
     
101. };
     
102. 
     
103. template<typename T>
     
104. void* Singleton<T>::m_instance = 0;
     
105. 
     
106. template<typename T>
     
107. CLock Singleton<T>::m_Lock;
     
108. 
     
109. HANDLE g_hThreads[3] = {0};
     
110. 
     
111. 
     
112. DWORD WINAPI func(LPVOID p)
     
113. {
     
114.     
     
115.     int i = 0;
     
116.     while(i < 5)
     
117.     {
     
118.         Singleton<TestClass>::instance().Inc();
     
119.         Singleton<TestClass>::instance().Show();
     
120. 
     
121.         Sleep(1);
     
122. 
     
123.         ++i;
     
124.     }
     
125. 
     
126.     return 1;
     
127. }
     
128. 
     
129. int main()
     
130. {
     
131.     for(int i = 0; i < 3; ++i)
     
132.     {
     
133.         g_hThreads[i] = ::CreateThread(NULL, 0, func, NULL, 0, NULL);
     
134.     }
     
135. 
     
136.     ::WaitForMultipleObjects(3, g_hThreads, TRUE, INFINITE );
     
137. 
     
138.     Singleton<TestClass>::release();
     
139. 
     
140.     std::cout << "finished" << std::endl;
     
141. 
     
142.     std::cout << "has create " << TestClass::num << " TestClass!" << std::endl;
     
143. 
     
144.     system("pause");
     
145. 
     
146.     return 0;
     
147. }

程序运行结果

x = 1
x = 2
x = 3
x = 4
x = 5
x = 6
x = 7
x = 9
x = 8
x = 10
x = 12
x = 11
x = 13
x = 14
x = 15
finished
has create 1 TestClass!

-------------------------------------------------------------------------------------------------

为了解决多线程环境，解决静态对象的删除，采用局部静态对象，得到最优化，最简约的单例模式如下:

#include <QtCore/QCoreApplication>
#include <QDebug>

class Singleton
{
private:
    Singleton() 
    {
        qDebug()<<"Contruct Singleton";
    }
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
 public:
    static Singleton * GetInstance()
    {
       static Singleton m_Single;
       return &m_Single;
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    Singleton *tmp = Singleton::GetInstance();
    return a.exec();
}