Linux平台用C++實現事件對象，同步線程

前文在Win32平台上用C++實現了事件對象Event，對線程進行同步（見 http://www.linuxidc.com/Linux/2011-12/49717.htm ），以達到期望目的。這次在Linux平台上實現與之類似的事件對象。與其相關的一組API包括：pthread_mutex_init，pthread_cond_init，pthread_mutex_lock，pthread_cond_wait，pthread_mutex_unlock，pthread_cond_broadcast，pthread_cond_timedwait，pthread_cond_destroy，pthread_mutex_destroy。下邊，是封裝的事件對象類，以及測試代碼。使用VS2005編輯，在虛擬機 Fedora 13中編譯，測試通過。

MyEvent.h

2. #ifndef My_Event_Header   
4. #define My_Event_Header   
5.   
6. #include <iostream>   
7. #include <pthread.h>   
8. #include <errno.h>   
9.   
10. using namespace std;  
11.   
12. //---------------------------------------------------------------   
13.   
14. class CEventImpl  
15. {  
16. protected:  
17.       
18.     /* 
19.      動態方式初始化互斥鎖,初始化狀態變量m_cond 
20.     `bAutoReset  true   人工重置 
21.                  false  自動重置 
22.     */  
23.     CEventImpl(bool manualReset);         
24.       
25.     /* 
26.      注銷互斥鎖,注銷狀態變量m_cond 
27.     */  
28.     ~CEventImpl();  
29.   
30.     /* 
31.      將當前事件對象設置為有信號狀態 
32.      若自動重置，則等待該事件對象的所有線程只有一個可被調度 
33.      若人工重置，則等待該事件對象的所有線程變為可被調度 
34.     */  
35.     void SetImpl();  
36.   
37.     /* 
38.      以當前事件對象，阻塞線程，將其永遠掛起 
39.      直到事件對象被設置為有信號狀態 
40.     */  
41.     bool WaitImpl();  
42.   
43.     /* 
44.      以當前事件對象，阻塞線程，將其掛起指定時間間隔 
45.      之後線程自動恢復可調度 
46.     */  
47.     bool WaitImpl(long milliseconds);  
48.   
49.     /* 
50.      將當前事件對象設置為無信號狀態 
51.     */  
52.     void ResetImpl();  
53.   
54. private:  
55.     bool            m_manual;  
56.     volatile bool   m_state;  
57.     pthread_mutex_t m_mutex;  
58.     pthread_cond_t  m_cond;  
59. };  
60.   
61. inline void CEventImpl::SetImpl()  
62. {  
63.     if (pthread_mutex_lock(&m_mutex))     
64.         cout<<"cannot signal event (lock)"<<endl;  
65.   
66.     //設置狀態變量為true，對應有信號   
67.     m_state = true;  
68.   
69.     //cout<<"CEventImpl::SetImpl m_state = "<<m_state<<endl;   
70.   
71.     //重新激活所有在等待m_cond變量的線程   
72.     if (pthread_cond_broadcast(&m_cond))  
73.     {  
74.         pthread_mutex_unlock(&m_mutex);  
75.         cout<<"cannot signal event"<<endl;  
76.     }  
77.     pthread_mutex_unlock(&m_mutex);  
78. }  
79.   
80. inline void CEventImpl::ResetImpl()  
81. {  
82.     if (pthread_mutex_lock(&m_mutex))     
83.         cout<<"cannot reset event"<<endl;  
84.   
85.     //設置狀態變量為false，對應無信號   
86.     m_state = false;  
87.   
88.     //cout<<"CEventImpl::ResetImpl m_state = "<<m_state<<endl;   
89.   
90.     pthread_mutex_unlock(&m_mutex);  
91. }  
92.   
93. //---------------------------------------------------------------   
94.   
95. class CMyEvent: private CEventImpl  
96. {  
97. public:  
98.     CMyEvent(bool bManualReset = true);  
99.     ~CMyEvent();  
100.   
101.     void Set();  
102.     bool Wait();  
103.     bool Wait(long milliseconds);  
104.     bool TryWait(long milliseconds);  
105.     void Reset();  
106.   
107. private:  
108.     CMyEvent(const CMyEvent&);  
109.     CMyEvent& operator = (const CMyEvent&);  
110. };  
111.   
112.   
113. inline void CMyEvent::Set()  
114. {  
115.     SetImpl();  
116. }  
117.   
118. inline bool CMyEvent::Wait()  
119. {  
120.     return WaitImpl();  
121. }  
122.   
123. inline bool CMyEvent::Wait(long milliseconds)  
124. {  
125.     if (!WaitImpl(milliseconds))  
126.     {  
127.         cout<<"time out"<<endl;  
128.         return false;  
129.     }  
130.     else  
131.     {  
132.         return true;  
133.     }  
134. }  
135.   
136. inline bool CMyEvent::TryWait(long milliseconds)  
137. {  
138.     return WaitImpl(milliseconds);  
139. }  
140.   
141. inline void CMyEvent::Reset()  
142. {  
143.     ResetImpl();  
144. }  
145.   
146. #endif