备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

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

2017-08-16 1309
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 前文在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

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


MyEvent.cpp

[cpp]  view plain  copy
 
  1. #include "MyEvent.h"  
  2. #include <sys/time.h>  
  3.   
  4. CEventImpl::CEventImpl(bool manualReset): m_manual(manualReset), m_state(false)  
  5. {  
  6.     if (pthread_mutex_init(&m_mutex, NULL))  
  7.         cout<<"cannot create event (mutex)"<<endl;  
  8.     if (pthread_cond_init(&m_cond, NULL))  
  9.         cout<<"cannot create event (condition)"<<endl;  
  10. }  
  11.   
  12. CEventImpl::~CEventImpl()  
  13. {  
  14.     pthread_cond_destroy(&m_cond);  
  15.     pthread_mutex_destroy(&m_mutex);  
  16. }  
  17.   
  18. bool CEventImpl::WaitImpl()  
  19. {  
  20.     if (pthread_mutex_lock(&m_mutex))  
  21.     {  
  22.         cout<<"wait for event failed (lock)"<<endl;   
  23.         return false;  
  24.     }  
  25.     while (!m_state)   
  26.     {  
  27.         //cout<<"CEventImpl::WaitImpl while m_state = "<<m_state<<endl;  
  28.   
  29.         //对互斥体进行原子的解锁工作,然后等待状态信号  
  30.         if (pthread_cond_wait(&m_cond, &m_mutex))  
  31.         {  
  32.             pthread_mutex_unlock(&m_mutex);  
  33.             cout<<"wait for event failed"<<endl;  
  34.             return false;  
  35.         }  
  36.     }  
  37.     if (m_manual)  
  38.         m_state = false;  
  39.     pthread_mutex_unlock(&m_mutex);  
  40.   
  41.     //cout<<"CEventImpl::WaitImpl end m_state = "<<m_state<<endl;  
  42.   
  43.     return true;  
  44. }  
  45.   
  46. bool CEventImpl::WaitImpl(long milliseconds)  
  47. {  
  48.     int rc = 0;  
  49.     struct timespec abstime;  
  50.     struct timeval tv;  
  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.     }  
  59.   
  60.     if (pthread_mutex_lock(&m_mutex) != 0)  
  61.     {  
  62.         cout<<"wait for event failed (lock)"<<endl;   
  63.         return false;  
  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<<"cannot wait for event"<<endl;  
  73.             return false;  
  74.         }  
  75.     }  
  76.     if (rc == 0 && m_manual)   
  77.         m_state = false;  
  78.     pthread_mutex_unlock(&m_mutex);  
  79.     return rc == 0;  
  80. }  
  81.   
  82. CMyEvent::CMyEvent(bool bManualReset): CEventImpl(bManualReset)  
  83. {  
  84. }  
  85.   
  86. CMyEvent::~CMyEvent()  
  87. {  
  88. }  


    下边是测试代码

[cpp]  view plain  copy
 
  1. // pthread_event.cpp : 定义控制台应用程序的入口点。  
  2. //  
  3.   
  4. #include <unistd.h>  
  5. #include "MyEvent.h"  
  6.   
  7. #define PRINT_TIMES 10  
  8.   
  9. //创建一个人工自动重置事件对象  
  10. CMyEvent g_myEvent;  
  11. int g_iNum = 0;  
  12.   
  13.   
  14. //线程函数1  
  15. void * ThreadProc1(void *pParam)  
  16. {  
  17.     for (int i = 0; i < PRINT_TIMES; i++)  
  18.     {  
  19.         g_iNum++;  
  20.         cout<<"ThreadProc1 do print, Num = "<<g_iNum<<endl;  
  21.   
  22.         //设置事件为有信号状态  
  23.         g_myEvent.Set();  
  24.   
  25.         sleep(1);  
  26.     }  
  27.   
  28.     return (void *)0;  
  29. }  
  30.   
  31. //线程函数2  
  32. void * ThreadProc2(void *pParam)  
  33. {  
  34.     bool bRet = false;  
  35.     while ( 1 )  
  36.     {  
  37.         if ( g_iNum >= PRINT_TIMES )  
  38.         {  
  39.             break;  
  40.         }  
  41.   
  42.         //以当前事件对象阻塞本线程，将其挂起  
  43.         bRet = g_myEvent.Wait();  
  44.         if ( bRet )  
  45.         {  
  46.             cout<<"ThreadProc2 do print, Num = "<<g_iNum<<endl;  
  47.   
  48.             //设置事件为无信号状态  
  49.             g_myEvent.Reset();  
  50.         }  
  51.         else  
  52.         {  
  53.             cout<<"ThreadProc2 system exception"<<endl;  
  54.         }  
  55.     }  
  56.   
  57.     return (void *)0;  
  58. }  
  59.   
  60.   
  61. int main(int argc, char* argv[])  
  62. {  
  63.     pthread_t thread1,thread2;  
  64.     pthread_attr_t attr1,attr2;  
  65.   
  66.   
  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<<"Thread 1: create failed"<<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<<"Thread 2: create failed"<<endl;  
  79.     }  
  80.   
  81.     //等待线程结束  
  82.     void *result;  
  83.     pthread_join(thread1,&result);  
  84.     pthread_join(thread2,&result);  
  85.   
  86.     //关闭线程，释放资源  
  87.     pthread_attr_destroy(&attr1);  
  88.     pthread_attr_destroy(&attr2);  
  89.   
  90.     int iWait;  
  91.     cin>>iWait;  
  92.   
  93.     return 0;  
  94. }  


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

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

文章标签：
C++
Linux
调度
API
关键词：
Linux线程
线程linux
Linux c++
C++ linux
Linux平台
double2li
目录
相关文章
fensnote
|
21天前
|
Linux C++
LInux下Posix的传统线程示例
LInux下Posix的传统线程示例
fensnote
18 1
SarPro
|
12天前
|
存储 算法 Linux
【实战项目】网络编程：在Linux环境下基于opencv和socket的人脸识别系统--C++实现
【实战项目】网络编程：在Linux环境下基于opencv和socket的人脸识别系统--C++实现
SarPro
32 6
泡沫o0
|
27天前
|
存储 算法 Java
【C/C++ 线程池设计思路】 深入探索线程池设计：任务历史记录的高效管理策略
【C/C++ 线程池设计思路】 深入探索线程池设计：任务历史记录的高效管理策略
泡沫o0
72 0
jianz123
|
14天前
|
Linux Shell 虚拟化
linux 部署docker容器虚拟化平台（二）--------docker 镜像制作方法
linux 部署docker容器虚拟化平台（二）--------docker 镜像制作方法
jianz123
21 0
泡沫o0
|
27天前
|
安全 Java 调度
【C/C++ 线程池设计思路 】设计与实现支持优先级任务的C++线程池 简要介绍
【C/C++ 线程池设计思路 】设计与实现支持优先级任务的C++线程池 简要介绍
泡沫o0
43 2
泡沫o0
|
27天前
|
Linux API C++
【C++ 线程包裹类设计】跨平台C++线程包装类：属性设置与平台差异的全面探讨
【C++ 线程包裹类设计】跨平台C++线程包装类：属性设置与平台差异的全面探讨
泡沫o0
51 2
泡沫o0
|
27天前
|
监控 Linux 调度
【Linux 应用开发 】Linux 下应用层线程优先级管理解析
【Linux 应用开发 】Linux 下应用层线程优先级管理解析
泡沫o0
45 0
泡沫o0
|
27天前
|
设计模式 安全 C++
【C++ const 函数 的使用】C++ 中 const 成员函数与线程安全性：原理、案例与最佳实践
【C++ const 函数 的使用】C++ 中 const 成员函数与线程安全性：原理、案例与最佳实践
泡沫o0
71 2
泡沫o0
|
27天前
|
监控 Linux 编译器
Linux C++ 定时器任务接口深度解析: 从理论到实践
Linux C++ 定时器任务接口深度解析: 从理论到实践
泡沫o0
70 2
泡沫o0
|
28天前
|
存储 Linux 程序员
【Linux C/C++ 堆内存分布】深入理解Linux进程的堆空间管理
【Linux C/C++ 堆内存分布】深入理解Linux进程的堆空间管理
泡沫o0
72 0

热门文章

最新文章

  • 1
    Java中的多线程编程：概念、实现与性能优化
  • 2
    【Qt 底层之事件驱动系统】深入理解 Qt 事件机制：主事件循环与工作线程的交互探究，包括 QML 的视角
  • 3
    Python 学习之路 01基础入门---【Python安装，Python程序基本组成】
  • 4
    【深入探究 Qt 线程】一文详细解析Qt线程的内部原理与实现策略
  • 5
    【软件设计师备考 专题 】操作系统的内核（中断控制）、进程、线程概念
  • 6
    【C/C++ 线程池设计思路】 深入探索线程池设计：任务历史记录的高效管理策略
  • 7
    【C++ const 函数 的使用】C++ 中 const 成员函数与线程安全性：原理、案例与最佳实践
  • 8
    线程同步与IPC：单进程多线程环境下的选择与权衡
  • 9
    深入理解Java并发编程：线程安全与性能优化
  • 10
    【C++ 线程包裹类设计】跨平台C++线程包装类：属性设置与平台差异的全面探讨
  • 1
    c++的学习之路：4、入门（3）
    11
  • 2
    c++的学习之路：23、多态（2）
    12
  • 3
    c++的学习之路：7、类和对象（3）
    16
  • 4
    c++的学习之路：5、类和对象（1）
    12
  • 5
    【C++】string类
    15
  • 6
    面向对象的C++题目以及解法2
    11
  • 7
    标准库中的string类（中）+仅仅反转字母+字符串中的第一个唯一字符+字符串相加——“C++”“Leetcode每日一题”
    19
  • 8
    标准库中的string类（上）——“C++”
    10
  • 9
    自从学了C++之后，小雅兰就有对象了！！！（类与对象）（中）——“C++”
    18
  • 10
    自从学了C++之后，小雅兰就有对象了！！！（类与对象）（上）——“C++”
    18

    • 相关课程

    更多
  • Linux高级网络应用 - 网络管理与配置实战
  • Linux Web服务器Nginx搭建与配置
  • 计算机基础与Linux入门
  • Linux企业运维实战 - 入门及常用命令
  • Linux Shell 编程入门与实战
  • Linux网络进阶 - TCP/IP协议及OSI七层模型

    • 相关电子书

    更多
  • Alibaba Cloud Linux 3 发布
  • ECS系统指南之Linux系统诊断
  • ECS运维指南 之 Linux系统诊断

    • 相关实验场景

    更多
  • 使用计算巢企业应用，一键获取专属的Linux服务器管理软件
  • Alibaba Cloud Linux操作系统的安装及使用
  • Alibaba Cloud Linux操作系统Shell程序
  • 手动部署MySQL数据库（Alibaba Cloud Linux 2）
  • 部署并使用Docker（Alibaba Cloud Linux 3）
  • 部署并使用Docker（Alibaba Cloud Linux 2）

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）