四极管：WaitForMultipleObjects的疑惑

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，就“死”了...

[c-sharp] view plain copy

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检测机制来实现。见下面的例子：

 

[cpp] view plain copy

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;  
37. }