Linux平台用C++实现事件对象，同步线程


前文在Win32平台上用C++实现了事件对象Event，对线程进行同步（见  ），以达到期望目的。这次在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  
  • 1
  • 2
  • 3
  • 下一页

相关内容