首页 / 操作系统 / Linux / 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