四极管:WaitForMultipleObjects的疑惑

原创 2012年03月06日 10:37:19

WaitForMultipleObjects

        函数貌似在许多系统中都会用到,四极管看得云里雾里的,知道怎么用,但是具体是怎么运行的,还是不知,先记下大家的见解,以后自己慢慢在项目中理解,也希望能有大牛帮讲解讲解。。。小弟在此感激不尽。

函数WaitForMultipleObjects整理

DWORD WaitForMultipleObjects(  DWORD nCount,  const HANDLE* lpHandles,  BOOL bWaitAll,  DWORD dwMilliseconds);

其中参数

nCount 句柄的数量 最大值为MAXIMUM_WAIT_OBJECTS(64)

HANDLE 句柄数组的指针。

HANDLE 类型可以为(Event,Mutex,Process,Thread,Semaphore )数组

BOOL bWaitAll 等待的类型,如果为TRUE 则等待所有信号量有效在往下执行,FALSE 当有其中一个信号量有效时就向下执行

DWORD dwMilliseconds 超时时间 超时后向执行。 如果为WSA_INFINITE 永不超时。如果没有信号量就会在这死等。

举个例子:当 bWaitAll参数为FALSE 可以等待其中之一的事件

HANDLE m_hEvent[2]; 

//两事件

m_hEvent[0]=::CreateEvent(NULL, FALSE, FALSE, NULL);

m_hEvent[1]=::CreateEvent(NULL, FALSE, FALSE, NULL);

::CreateThread(NULL, 0, MyThreadProc, this, 0, NULL);

DWORD WINAPI MyThreadProc(LPVOID lpParam)

{

while(TRUE)

 {  //每次等500毫秒

 int nIndex = ::WaitForMultipleObjects(2, pThis->m_hEvent, FALSE,500);  

 if (nIndex == WAIT_OBJECT_0 + 1)

 {

 //第二个事件发生   //ExitThread(0);   //break; 

}

 else if (nIndex == WAIT_OBJECT_0) //第一个事件发生 

{

  //第一个事件

   } 

else if (nIndex == WAIT_TIMEOUT) //超时500毫秒 

{   //超时可作定时用 

}

}

 ::OutputDebugString("线程结束. \n");

 return 0L;}

当要处理第一个事件时,你只需执行SetEvent(m_hEvent[0]);

即可进入第一个事件的位置

当要执行第二个事件时执行SetEvent(m_hEvent[1]); 

 当 bWaitAll参数为TRUE 等待所有的事件

 DWORD WINAPI MyThreadProc(LPVOID lpParam)

{ while(TRUE)

 {  //每次等500毫秒 

int nIndex = ::WaitForMultipleObjects(2, pThis->m_hEvent, TRUE,500);  

  if (WAIT_OBJECT_0 + 1<= nIndex <= WAIT_OBJECT_0) //所有事件发生

 {

  //所有的信号量都有效时(事件都发生)其中之一无效。

 }

 else if (nIndex == WAIT_TIMEOUT) //超时500毫秒 

{   //超时可作定时用  }

 }

return 0L;}

必须同时执行以下两个事件才可以(只执行一个无效)

SetEvent(m_hEvent[0]);

SetEvent(m_hEvent[1]);


文章出处:http://www.diybl.com/course/3_program/c++/cppsl/2008711/132765.html


话题】有没有人知道 WaitForMultipleObjects 是怎么实现的?一个现象好奇怪,请教下

2009-05-14 00:04:24 来自:孙志浩 浏览数:69
C/C++ code#include <Windows.h>#include <iostream>using namespace std;int curindex = 1;HANDLE obj[2];DWORD WINAPI WorkerThread(LPVOID lpParam){ int a; cin>>a; obj[1] = CreateEvent(0,TRUE,TRUE,NULL); curindex = 2; return 1;}int main(){ obj[0]= CreateEvent(0,TRUE,FALSE,NULL); DWORD dwThreadId; // Create worker thread CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId); WaitForMultipleObjects(curindex, obj, FALSE, INFINITE); return 0;}

obj[0]是无信号的 WaitForMultipleObjects 就应该阻塞在这
在另一个线程中随便输入个整数,是创建obj[1],使之有信号,并改变curindex,理论上这个时候 WaitForMultipleObjects 应该返回,程序结束

但实际不是这样

那由此想到的 socket 通信 的 select 模式,如果也阻塞在其中一个客户端上,那么其余客户端即使连接上也不会收到有信号状态
 
muslix64回复于14日02点50分 


obj[1] = CreateEvent(0,TRUE,TRUE,NULL);//难道你不觉得这已经是有信号状态吗,注意参数;

我这个程序是想要试验下:在全部是无信号状态下 WaitForMultipleObjects 阻塞,然后加一个有信号状态的事件看看这个阻塞的函数会不会结束

从 select 模式考虑应该是这样的,但这程序结果不是
 
林天成回复于14日03点02分 
C/C++ code#include <stdio.h> #include <Windows.h>#include <iostream>using namespace std;int curindex = 1;HANDLE obj[2];DWORD WINAPI WorkerThread(LPVOID lpParam){ int a; cout<<"1线程\n"; cin>>a; obj[1] = CreateEvent(0,TRUE,TRUE,NULL); curindex = 2; cout<<"1线程退出\n"; SetEvent(obj[0]);//难道你不觉得应该设置为信号态吗; return 1;}int main(){ obj[0]= CreateEvent(0,TRUE,FALSE,NULL); DWORD dwThreadId; // Create worker thread CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId); WaitForMultipleObjects(curindex, obj, FALSE, INFINITE); return 0;}
 
chen叶子回复于14日03点13分 


我要的就是这个“死”了之后,在给这个事件数组加个有信号的事件看看会不会再“活”过来
但实验结果好像不“活”,那么就好奇于socket 通信 的 select 模式,WaitForMultipleObjects也是阻塞,那么其余客户端事件没法把它救“活”那不都“死”了
 
成事在天回复于14日03点25分 
mark.up
 
鼠年鼠弟回复于14日03点36分 
以下代码,它展示了通过使用多线程函数或者多次调用一个单线程函数,可以创建多个的后台线程。 
   
  #include   
  #include   
  #include   
   
  typedef  struct 
  { 
  DWORD  frequency; 
  DWORD  duration; 
  DWORD  iterations; 
  }  honkParams; 
   
  void  HonkThread(honkParams  *params) 
  { 
  DWORD  i; 
   
  for  (i=0;  i  <  params->iterations;  i++) 
  { 
  Beep(params->frequency,  params->duration); 
  Sleep(1000); 
  } 
   
  GlobalFree(params); 
  } 
   
  void  main(void) 
  { 
  HANDLE  honkHandles[3]; 
  DWORD  threadID; 
  honkParams  *params; 
  DWORD  count; 
  CHAR  freqStr[100]; 
  CHAR  durStr[100]; 
  CHAR  iterStr[100]; 
   
  for  (count=0;  count  <  3;  count++) 
  { 
  //  allocate  memory  for  a  "params"  structure 
  params=(honkParams  *)  GlobalAlloc(GPTR,   
  sizeof(honkParams)); 
   
  cout  < <  "Enter  the  beep  frequency:  "; 
  cin.getline(freqStr,  100); 
  params->frequency=atoi(freqStr); 
   
  cout  < <  "Enter  the  beep  duration:  "; 
  cin.getline(durStr,  100); 
  params->duration=atoi(durStr); 
   
  cout  < <  "Enter  the  number  of  beeps:  "; 
  cin.getline(iterStr,  100); 
  params->iterations=atoi(iterStr); 
   
  //  create  a  thread  and  pass  it  the  pointer   
  //  to  its  "params"  struct 
  honkHandles[count]=CreateThread(0,  0, 
  (LPTHREAD_START_ROUTINE)  HonkThread,   
  params,  0,  &threadID); 
  } 
   
  //  wait  for  all  threads  to  finish  execution 
  WaitForMultipleObjects(3,  honkHandles,   
  TRUE,  INFINITE);   
  } 
   
   
    在运行以上代码时,该程序将会要求你输入一个频率、持续时间和发出响声的次数。你可以做三次这样的处理,如果你为每个线程设置足够高的发声次数的话,你将可以听到三个线程同时发出嘟嘟的响声。 
 
shoshana回复于14日03点44分 
在Wait之前先把事件创建好吧;或者试试用Wait的超时机制,超时后再等待,如下
C/C++ code#include <Windows.h>#include <iostream>using namespace std;int curindex = 1;HANDLE obj[2];DWORD WINAPI WorkerThread(LPVOID lpParam){ int a; cin>>a; obj[1] = CreateEvent(0,TRUE,TRUE,NULL); curindex = 2; return 1;}int main(){ obj[0]= CreateEvent(0,TRUE,FALSE,NULL); DWORD dwThreadId; // Create worker thread CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId); DWORD ret; do { ret = WaitForMultipleObjects(curindex, obj, FALSE, 1000); } while( WAIT_TIMEOUT == ret ); //若超时,则继续等待,curindex可随着线程的执行而被改变,从而等待不同数量的事件 return 0;}
 
baobaojiazhang回复于14日03点51分 

WaitForSingleObject用于在某个对象(同步事件对象句柄、文件修改句柄、进程或线程句柄等)上阻塞线程(此时不占用CPU资源),直到传递给它的第一个参数被设置为信号点亮状态时,函数返回。它的第二个参数设置了等待时间,如果设置该参数为INFINITE,则WaitForSingleObject将无限期阻塞线程,直到第一个参数被设置为信号点亮状态。但是有时通过将第二个参数设置为0(不等待),并配合WaitForSingleObject的返回值(WAIT_OBJECT_0表示对象进入信号状态返回,WAIT_TIMEOUT表示超时返回)达到检测第一个参数状态的目的,这可以用于检测结束线程的信号是否被设置为信号状态以结束线程。但是值得注意的是,在将WaitForSingleObject的第二个参数设置为0来检查信号状态时,若第一个参数为同步事件对象,则该对象必须为手动事件,这是因为WaitForSingleObject每检查一次自动事件对象就将其重置。WaitForMultipleObjects在原理上与WaitForSingleObject相同,只是可以对多个对象进行监视而已。
 
爱你一万年回复于14日04点02分 
CreateThread(NULL, 0, WorkerThread, NULL, 0, &dwThreadId);
WaitForMultipleObjects(curindex, obj, FALSE, INFINITE);
----------------------------
请问lz如何保证WorkerThread在WaitForMultipleObjects之前执行? 如果执行Wait时,curindex=1,就“死”了...



  1. DWORD WaitForMultipleObjects(  
  2.   DWORD nCount,             // number of handles in the handle array  
  3.   CONST HANDLE *lpHandles,  // pointer to the object-handle array  
  4.   BOOL fWaitAll,            // wait flag  
  5.   DWORD dwMilliseconds      // time-out interval in milliseconds  
  6. );  
  7.   
  8. 其中参数   
  9.   
  10. nCount 句柄的数量 最大值为MAXIMUM_WAIT_OBJECTS(64)  
  11.   
  12. HANDLE 句柄数组的指针。  
  13.   
  14. HANDLE 类型可以为(Event,Mutex,Process,Thread,Semaphore )数组  
  15.   
  16. BOOL bWaitAll 等待的类型,如果为TRUE 则等待所有信号量有效在往下执行,FALSE 当有其中一个信号量有效时就向下执行  
  17.   
  18. DWORD dwMilliseconds 超时时间 超时后向执行。 如果为WSA_INFINITE 永不超时。如果没有信号量就会在这死等。  
  19.   
  20. 举个例子:当 bWaitAll参数为FALSE 可以等待其中之一的事件  
  21.   
  22. HANDLE m_hEvent[2];    
  23.   
  24. //两事件  
  25.   
  26. m_hEvent[0]=::CreateEvent(NULL, FALSE, FALSE, NULL);  
  27.   
  28. m_hEvent[1]=::CreateEvent(NULL, FALSE, FALSE, NULL);  
  29.   
  30. ::CreateThread(NULL, 0, MyThreadProc, this, 0, NULL);  
  31.   
  32. DWORD WINAPI MyThreadProc(LPVOID lpParam)  
  33.   
  34. {   
  35.   
  36. while(TRUE)  
  37.   
  38.  {  //每次等500毫秒   
  39.   
  40.  int nIndex = ::WaitForMultipleObjects(2, pThis->m_hEvent, FALSE,500);     
  41.   
  42.  if (nIndex == WAIT_OBJECT_0 + 1)   
  43.   
  44.  {  
  45.   
  46.  //第二个事件发生   //ExitThread(0);   //break;    
  47.   
  48. }   
  49.   
  50.  else if (nIndex == WAIT_OBJECT_0) //第一个事件发生    
  51.   
  52. {   
  53.   
  54.   //第一个事件  
  55.   
  56.    }    
  57.   
  58. else if (nIndex == WAIT_TIMEOUT) //超时500毫秒    
  59.   
  60. {   //超时可作定时用    
  61.   
  62. }   
  63.   
  64. }  
  65.   
  66.  ::OutputDebugString("线程结束. /n");  
  67.   
  68.  return 0L;}  
  69.   
  70. 当要处理第一个事件时,你只需执行SetEvent(m_hEvent[0]);  
  71.   
  72. 即可进入第一个事件的位置  
  73.   
  74. 当要执行第二个事件时执行SetEvent(m_hEvent[1]);    
  75.   
  76.  当 bWaitAll参数为TRUE 等待所有的事件  
  77.   
  78.  DWORD WINAPI MyThreadProc(LPVOID lpParam)  
  79.   
  80. while(TRUE)  
  81.   
  82.  {  //每次等500毫秒    
  83.   
  84. int nIndex = ::WaitForMultipleObjects(2, pThis->m_hEvent, TRUE,500);     
  85.   
  86.   if (WAIT_OBJECT_0 + 1<= nIndex <= WAIT_OBJECT_0) //所有事件发生   
  87.   
  88.  {   
  89.   
  90.   //所有的信号量都有效时(事件都发生)其中之一无效。   
  91.   
  92.  }   
  93.   
  94.   
  95. 文章出处:http://www.diybl.com/course/3_program/c++/cppsl/2008711/132765.html  

当WaitForMultipleObjects()等到多个内核对象的时候,

如果它的bWaitAll 参数设置为false。其返回值减去WAIT_OBJECT_0 就是参数lpHandles数组的序号。

如果同时有多个内核对象被出发,这个函数返回的只是其中序号最小的那个。

问题就在这里,我们如何可以获取所有被同时触发的内核对象。

举个例子:我们需要在一个线程中处理从完成端口、数据库、和可等待定时器来的数据。

一个典型的实现方法就是:用WaitForMultipleObjects等待所有的这些事件。

如果完成端口,数据库发过来的数据量非常大,可等待定时器时间也只有几十毫秒。

那么这些事件同时触发的几率可以说非常大,我们不希望丢弃任何一个被触发的事件。那么如何能高效地实现这一处理呢?

 

多个内核对象被触发时,WaitForMultipleObjects选择其中序号最小的返回。而WaitForMultipleObjects它只会改变使它返回的那个内核对象的状态。
这儿又会产生一个问题,如果序号最小的那个对象频繁被触发,那么序号比它大的内核对象将的不到被出理的机会。
 为了解决这一问题,可以采用双WaitForMultipleObjects检测机制来实现。见下面的例子:

 

  1. DWORD WINAPI ThreadProc(LPVOID lpParameter)  
  2. {  
  3. DWORD dwRet = 0;  
  4. int nIndex = 0;   
  5. while(1)  
  6. {dwRet = WaitForMultipleObjects(nCount,pHandles,false,INFINITE);  
  7. switch(dwRet)  
  8. {  
  9. case WAIT_TIMEOUT:  
  10. break;  
  11. case WAIT_FAILED:  
  12. return 1;   
  13. default:   
  14. {   
  15. nIndex = dwRet - WAIT_OBJECT_0;   
  16. ProcessHanlde(nIndex++); //同时检测其他的事件 while(nIndex < nCount)  
  17. {  
  18. dwRet = WaitForMultipleObjects(nCount - nIndex,&pHandles[nIndex],false,0);  
  19. switch(dwRet)  
  20. case WAIT_TIMEOUT:   
  21. nIndex = nCount; //退出检测,因为没有被触发的对象了.   
  22. break;  
  23. case WAIT_FAILED:  
  24. return 1;  
  25. default:   
  26. { nIndex = dwRet - WAIT_OBJECT_0;  
  27. ProcessHanlde(nIndex++);  
  28. }   
  29. break;  
  30. }  
  31. }  
  32. }  
  33. break;  
  34. }  
  35. }   
  36. return 0;  


WaitForMultipleObjects的疑惑

WaitForMultipleObjects         函数貌似在许多系统中都会用到,四极管看得云里雾里的,知道怎么用,但是具体是怎么运行的,还是不知,先记下大家的见解,以后自己慢慢在项目中理...

四极管:串口驱动的具体开发(一)

来源于《Windows CE 工程实践与完全解析》 由于WinCE的串口驱动程序的MDD层是由微软提供的。MDD层与PDD层之间的PDD COMMON层也是通用型设计,尽管必要时我们可以对他做修...

四极管:C++builder 文件及目录的操作

文章是转的,但是发现有些问题,现在补上: 一、判断目录是否存在:           C++   Builder中提供了检查文件是否存在的函数FileExists,indows   程序实现...

四极管:2410启动代码分析之 vector.s详解一

根据各方面资料,整理了一下··未完待续 ;下面是对ARM处理器模式寄存器对应值的常数定义,ARM处理器中有一个CPSR程序状态寄存器,它的后;;五位决定目前的处理模式 USERMODE  EQU ...

四极管:AD/DA AVR 之 549和5615

549: 四极管:AD549(TLC_549.C) #ifndef TLC549_C #define TLC549_C /*******************************...

四极管 EBOOT调试(下载功能OEM函数)

四极管 EBOOT调试(下载功能OEM函数) OEMReadData--------------------该函数负责从下载端口读取操作系统镜像数据 OEMMapMemAddr----------...

四极管:container_of 理解

来源于泡泡的博客。。。 问题:如何通过结构中的某个变量获取结构本身的指针??? 关于container_of见kernel.h中: /** * container_of - cast a ...

四极管:Windows CE stepldr源码----基于Windows CE 5.0 S3C2440 BSP

一、nboot与stepldr: 国内很多人做WinCE都是使用Samsung的2410或者2440入门的,所以对nboot和eboot是最熟悉的。eboot是微软在WinCE里面提供的开放源代码的...

四极管: WINCE设备流驱动举例

参考gooogleman大兄的文档及ouravr一位兄弟整理出来的··实验无问题 一、编写流驱动程序有两种方法:一种是使用Platform Builder60的动态库生成向导生成器生成一个动态链接库...

四极管:Ubuntu 10.04设置Samba服务器

1.前沿 在网上找了许多设置共享的,但是发现都是大同小异,而已内容过久,比如下面两个链接中的内容。http://jimmy-shine.iteye.com/blog/141016,http://ww...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:四极管:WaitForMultipleObjects的疑惑
举报原因:
原因补充:

(最多只允许输入30个字)