思享工具箱

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。下边，是封装的事件对象类，以及测试代码。

前文在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。这些API的说明可以在这里找到：http://www.9linux.com/。下边，是封装的事件对象类，以及测试代码。使用VS2005编辑，在虚拟机 Fedora 13中编译，测试通过。

MyEvent.h

  1. #ifndefMy_Event_Header
  2. #defineMy_Event_Header
  4. #include<iostream>
  5. #include<pthread.h>
  6. #include<errno.h>
  8. usingnamespacestd;
  10. //---------------------------------------------------------------
  12. classCEventImpl
  13. {
  14. protected:
  16. /*
  17. 动态方式初始化互斥锁,初始化状态变量m_cond
  18. `bAutoResettrue人工重置
  19. false自动重置
  20. */
  21. CEventImpl(boolmanualReset);
  23. /*
  24. 注销互斥锁,注销状态变量m_cond
  25. */
  26. ~CEventImpl();
  28. /*
  29. 将当前事件对象设置为有信号状态
  30. 若自动重置，则等待该事件对象的所有线程只有一个可被调度
  31. 若人工重置，则等待该事件对象的所有线程变为可被调度
  32. */
  33. voidSetImpl();
  35. /*
  36. 以当前事件对象，阻塞线程，将其永远挂起
  37. 直到事件对象被设置为有信号状态
  38. */
  39. boolWaitImpl();
  41. /*
  42. 以当前事件对象，阻塞线程，将其挂起指定时间间隔
  43. 之后线程自动恢复可调度
  44. */
  45. boolWaitImpl(longmilliseconds);
  47. /*
  48. 将当前事件对象设置为无信号状态
  49. */
  50. voidResetImpl();
  52. private:
  53. boolm_manual;
  54. volatileboolm_state;
  55. pthread_mutex_tm_mutex;
  56. pthread_cond_tm_cond;
  57. };
  59. inlinevoidCEventImpl::SetImpl()
  60. {
  61. if(pthread_mutex_lock(&m_mutex))
  62. cout<<"cannotsignalevent(lock)"<<endl;
  64. //设置状态变量为true，对应有信号
  65. m_state=true;
  67. //cout<<"CEventImpl::SetImplm_state="<<m_state<<endl;
  69. //重新激活所有在等待m_cond变量的线程
  70. if(pthread_cond_broadcast(&m_cond))
  71. {
  72. pthread_mutex_unlock(&m_mutex);
  73. cout<<"cannotsignalevent"<<endl;
  74. }
  75. pthread_mutex_unlock(&m_mutex);
  76. }
  78. inlinevoidCEventImpl::ResetImpl()
  79. {
  80. if(pthread_mutex_lock(&m_mutex))
  81. cout<<"cannotresetevent"<<endl;
  83. //设置状态变量为false，对应无信号
  84. m_state=false;
  86. //cout<<"CEventImpl::ResetImplm_state="<<m_state<<endl;
  88. pthread_mutex_unlock(&m_mutex);
  89. }
  91. //---------------------------------------------------------------
  93. classCMyEvent:privateCEventImpl
  94. {
  95. public:
  96. CMyEvent(boolbManualReset=true);
  97. ~CMyEvent();
  99. voidSet();
  100. boolWait();
  101. boolWait(longmilliseconds);
  102. boolTryWait(longmilliseconds);
  103. voidReset();
  105. private:
  106. CMyEvent(constCMyEvent&);
  107. CMyEvent&operator=(constCMyEvent&);
  108. };
  111. inlinevoidCMyEvent::Set()
  112. {
  113. SetImpl();
  114. }
  116. inlineboolCMyEvent::Wait()
  117. {
  118. returnWaitImpl();
  119. }
  121. inlineboolCMyEvent::Wait(longmilliseconds)
  122. {
  123. if(!WaitImpl(milliseconds))
  124. {
  125. cout<<"timeout"<<endl;
  126. returnfalse;
  127. }
  128. else
  129. {
  130. returntrue;
  131. }
  132. }
  134. inlineboolCMyEvent::TryWait(longmilliseconds)
  135. {
  136. returnWaitImpl(milliseconds);
  137. }
  139. inlinevoidCMyEvent::Reset()
  140. {
  141. ResetImpl();
  142. }
  144. #endif

MyEvent.cpp

  1. #include"MyEvent.h"
  2. #include<sys/time.h>
  4. CEventImpl::CEventImpl(boolmanualReset):m_manual(manualReset),m_state(false)
  5. {
  6. if(pthread_mutex_init(&m_mutex,NULL))
  7. cout<<"cannotcreateevent(mutex)"<<endl;
  8. if(pthread_cond_init(&m_cond,NULL))
  9. cout<<"cannotcreateevent(condition)"<<endl;
  10. }
  12. CEventImpl::~CEventImpl()
  13. {
  14. pthread_cond_destroy(&m_cond);
  15. pthread_mutex_destroy(&m_mutex);
  16. }
  18. boolCEventImpl::WaitImpl()
  19. {
  20. if(pthread_mutex_lock(&m_mutex))
  21. {
  22. cout<<"waitforeventfailed(lock)"<<endl;
  23. returnfalse;
  24. }
  25. while(!m_state)
  26. {
  27. //cout<<"CEventImpl::WaitImplwhilem_state="<<m_state<<endl;
  29. //对互斥体进行原子的解锁工作,然后等待状态信号
  30. if(pthread_cond_wait(&m_cond,&m_mutex))
  31. {
  32. pthread_mutex_unlock(&m_mutex);
  33. cout<<"waitforeventfailed"<<endl;
  34. returnfalse;
  35. }
  36. }
  37. if(m_manual)
  38. m_state=false;
  39. pthread_mutex_unlock(&m_mutex);
  41. //cout<<"CEventImpl::WaitImplendm_state="<<m_state<<endl;
  43. returntrue;
  44. }
  46. boolCEventImpl::WaitImpl(longmilliseconds)
  47. {
  48. intrc=0;
  49. structtimespecabstime;
  50. structtimevaltv;
  51. gettimeofday(&tv,NULL);
  52. abstime.tv_sec=tv.tv_sec+milliseconds/1000;
  53. abstime.tv_nsec=tv.tv_usec*1000+(milliseconds%1000)*1000000;
  54. if(abstime.tv_nsec>=1000000000)
  55. {
  56. abstime.tv_nsec-=1000000000;
  57. abstime.tv_sec++;
  58. }
  60. if(pthread_mutex_lock(&m_mutex)!=0)
  61. {
  62. cout<<"waitforeventfailed(lock)"<<endl;
  63. returnfalse;
  64. }
  65. while(!m_state)
  66. {
  67. //自动释放互斥体并且等待m_cond状态,并且限制了最大的等待时间
  68. if((rc=pthread_cond_timedwait(&m_cond,&m_mutex,&abstime)))
  69. {
  70. if(rc==ETIMEDOUT)break;
  71. pthread_mutex_unlock(&m_mutex);
  72. cout<<"cannotwaitforevent"<<endl;
  73. returnfalse;
  74. }
  75. }
  76. if(rc==0&&m_manual)
  77. m_state=false;
  78. pthread_mutex_unlock(&m_mutex);
  79. returnrc==0;
  80. }
  82. CMyEvent::CMyEvent(boolbManualReset):CEventImpl(bManualReset)
  83. {
  84. }
  86. CMyEvent::~CMyEvent()
  87. {
  88. }

下边是测试代码

  1. //pthread_event.cpp:定义控制台应用程序的入口点。
  2. //
  4. #include<unistd.h>
  5. #include"MyEvent.h"
  7. #definePRINT_TIMES10
  9. //创建一个人工自动重置事件对象
  10. CMyEventg_myEvent;
  11. intg_iNum=0;
  14. //线程函数1
  15. void*ThreadProc1(void*pParam)
  16. {
  17. for(inti=0;i<PRINT_TIMES;i++)
  18. {
  19. g_iNum++;
  20. cout<<"ThreadProc1doprint,Num="<<g_iNum<<endl;
  22. //设置事件为有信号状态
  23. g_myEvent.Set();
  25. sleep(1);
  26. }
  28. return(void*)0;
  29. }
  31. //线程函数2
  32. void*ThreadProc2(void*pParam)
  33. {
  34. boolbRet=false;
  35. while(1)
  36. {
  37. if(g_iNum>=PRINT_TIMES)
  38. {
  39. break;
  40. }
  42. //以当前事件对象阻塞本线程，将其挂起
  43. bRet=g_myEvent.Wait();
  44. if(bRet)
  45. {
  46. cout<<"ThreadProc2doprint,Num="<<g_iNum<<endl;
  48. //设置事件为无信号状态
  49. g_myEvent.Reset();
  50. }
  51. else
  52. {
  53. cout<<"ThreadProc2systemexception"<<endl;
  54. }
  55. }
  57. return(void*)0;
  58. }
  61. intmain(intargc,char*argv[])
  62. {
  63. pthread_tthread1,thread2;
  64. pthread_attr_tattr1,attr2;
  67. //创建两个工作线程
  68. pthread_attr_init(&attr1);
  69. pthread_attr_setdetachstate(&attr1,PTHREAD_CREATE_JOINABLE);
  70. if(pthread_create(&thread1,&attr1,ThreadProc1,NULL)==-1)
  71. {
  72. cout<<"Thread1:createfailed"<<endl;
  73. }
  74. pthread_attr_init(&attr2);
  75. pthread_attr_setdetachstate(&attr2,PTHREAD_CREATE_JOINABLE);
  76. if(pthread_create(&thread2,&attr2,ThreadProc2,NULL)==-1)
  77. {
  78. cout<<"Thread2:createfailed"<<endl;
  79. }
  81. //等待线程结束
  82. void*result;
  83. pthread_join(thread1,&result);
  84. pthread_join(thread2,&result);
  86. //关闭线程，释放资源
  87. pthread_attr_destroy(&attr1);
  88. pthread_attr_destroy(&attr2);
  90. intiWait;
  91. cin>>iWait;
  93. return0;
  94. }

编译，运行。可以看到，与Win32平台上的测试结果相同，好神奇！

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

from:http://blog.csdn.net/chexlong/article/details/7080537

标签：#线程#线程阻塞#linux系统#pthread | 浏览：189 | 发布日期：

免责声明：文章转载自《Linux平台用C++实现事件对象，同步线程》仅用于学习参考。如对内容有疑问，请及时联系本站处理。

上篇二、实践与视频解决方案p标签多行文字内容实现上下垂直居中兼容ie8下篇

宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=

相关文章

linux清理内存命令

  1.清理前内存使用情况 free -m 2.开始清理  echo 1 > /proc/sys/vm/drop_caches3.清理后内存使用情况 free -m4.完成!查看内存条数命令： dmidecode | grep -A16 "Memory Device$" ++++++++++++++++++++++++++++++++++++...

关于deepin如何把CD制作成iso的测试

这不是无聊的测试。之前论坛里有朋友寻问deepin如何把cd制作成iso，有提问就应该有需求，一般大神的回答只是提示几个关键词，所以我们小白是理解不透的。 为了搞清楚这个问题，老陌本着实事求事的态度测试了一下，最终老陌测试成功，收获了知识与喜悦。下面把我的测试步骤整理分享一下： 由于没有光驱，老陌早上起来在虚拟机里安装了深度操作系统，这样在虚拟机中就有光驱...

WPF 不支持从调度程序线程以外的线程对其 SourceCollection 进行的更改

该问题出现在WPF中的VM类中，ObservableCollection类型，该类型的 CollectionView 不支持从调度程序线程以外的线程对其 SourceCollection 进行的更改，解决办法： ThreadPool.QueueUserWorkItem(delegate { Synch...

Android Handler与多线程

本文首先解释一下handler是用来干嘛的，然后通过例子介绍其在多线程中的应用。 什么是Handler      handler通俗一点讲就是用来在各个进程之间发送数据的处理对象。在任何进程中，只要获得了另一个进程的handler则可以通过 handler.sendMessage(message)方法向那个进程发送数据。基于这个机制，我们在处理多线程的时...

Linux-c给线程取名字

https://blog.csdn.net/jasonchen_gbd/article/details/51308638 1 #define wtm_set_thread_name(n) ({ 2 char tname[THREAD_NAME_LEN + 1] = ""; 3 if (strlen(n) > THREAD_N...

查看linux操作系统版本

转自：https://www.cnblogs.com/vaelailai/p/7545166.html 一、linux下如何查看已安装的centos版本信息： 1.Linux查看当前操作系统版本信息  cat /proc/version Linux version 2.6.32-696.el6.x86_64 (mockbuild@c1bm.rdu2.cen...

最新文章

随机推荐

思享工具箱导航