WaitForSingleObject和WaitForMultipleObjects用法

转自：http://www.360doc.com/content/10/0512/09/1072296_27178529.shtml

等待函数可使线程自愿进入等待状态，直到一个特定的内核对象变为已通知状态为止。这些等待函数中最常用的是WaitForSingleObject:

DWORD WaitForSingleObject(HANDLE hObject, DWORD dwMilliseconds);

当线程调用该函数时，第一个参数hObject标识一个能够支持被通知/未通知的内核对象。第二个参数dwMilliseconds.允许该线程指明，为了等待该对象变为已通知状态，它将等待多长时间。调用下面这个函数将告诉系统，调用函数准备等待到hProcess句柄标识的进程终止运行为止：

WaitForSingleObject(hProcess, INFINITE);

第二个参数告诉系统，调用线程愿意永远等待下去（无限时间量），直到该进程终止运行。

通常情况下， INFINITE是作为第二个参数传递给WaitForSingleObject的，不过也可以传递任何一个值（以毫秒计算）。顺便说一下， INFINITE已经定义为0xFFFFFFFF（或-1）。当然，传递INFINITE有些危险。如果对象永远不变为已通知状态，那么调用线程永远不会被唤醒，它将永远处于死锁状态，

不过，它不会浪费宝贵的CPU时间。

下面是如何用一个超时值而不是INFINITE来调用WaitForSingleObject的例子：

DWORD dw = WaitForSingleObject(hProcess, 5000);

switch(dw)

{

case WAIT_OBJECT_0:

// The process terminated.

break;

case WAIT_TIMEOUT:

// The process did not terminate within 5000 milliseconds.

break;

case WAIT_FAILED:

// Bad call to function (invalid handle?)

break;

}

上面这个代码告诉系统，在特定的进程终止运行之前，或者在5 0 0 0 m s时间结束之前，调用线程不应该变为可调度状态。因此，如果进程终止运行，那么这个

函数调用将在不到5000ms的时间内返回，如果进程尚未终止运行，那么它在大约5000ms时间内返回。注意，不能为dwMilliseconds传递0。如果传递了0，WaitForSingleObject函数将总是立即返回。WaitForSingleObject的返回值能够指明调用线程为什么再次变为可调度状态。如果线程等待的对象变为已通知状态，那么返回值是WAIT_OBJECT_0。如果设置的超时已经到期，则返回值是WAIT_TIMEOUT。如果将一个错误的值（如一个无效句柄）传递给WaitForSingleObject，那么返回值将是WAIT_FAILED（若要了解详细信息，可调用GetLastError）。

下面这个函数WaitForMultipleObjects与WaitForSingleObject函数很相似，区别在于它允许调用线程同时查看若干个内核对象的已通知状态：

DWORD WaitForMultipleObjects(DWORD dwCount,

CONST HANDLE* phObjects,

BOOL fWaitAll,

DWORD dwMilliseconds);

dwCount参数用于指明想要让函数查看的内核对象的数量。这个值必须在1与MAXIMUM_WAIT_OBJECTS（在Windows头文件中定义为64）之间。phObjects参数是指向内核对象句柄的数组的指针。

可以以两种不同的方式来使用WaitForMultipleObjects函数。

一种方式是让线程进入等待状态，直到指定内核对象中的任何一个变为已通知状态。

另一种方式是让线程进入等待状态，直到所有指定的内核对象都变为已通知状态。fWaitAll参数告诉该函数，你想要让它使用何种方式。如果为该参数传递TRUE，那么在所有对象变为已通知状态之前，该函数将不允许调用线程运行。

dwMilliseconds参数的作用与它在WaitForSingleObject中的作用完全相同。如果在等待的时候规定的时间到了，那么该函数无论如何都会返回。同样，通常为该参数传递INFINITE，但是在编写代码时应该小心，以避免出现死锁情况。

WaitForMultipleObjects函数的返回值告诉调用线程，为什么它会被重新调度。可能的返回值是WAIT_FAILED和WAIT_TIMEOUT，这两个值的作用是很清楚的。如果fWaitAll参数传递TRUE，同时所有对象均变为已通知状态，那么返回值是WAIT_OBJECT_0。如果为fWaitAll传递FALSE，那么一旦任何一个对象变为已通知状态，该函数便返回。在这种情况下，你可能想要知道哪个对象变为已通知状态。返回值是WAIT_OBJECT_0 与（WAIT_OBJECT_0 + dwCount-1）之间的一个值。换句话说，如果返回值不是WAIT_TIMEOUT，也不是WAIT_FAILED，那么应该从返回值中减去WAIT_OBJECT_0。产生的数字是作为第二个参数传递给WaitForMultipleObjects的句柄数组中的索引。该索引说明哪个对象变为已通知状态。

下面是说明这一情况的一些示例代码：

HANDLE h[3];

h[0] = hProcess1;

h[1] = hProcess2;

h[2] = hProcess3;

DWORD dw = WaitForMultipleObjects(3, h, FALSE, 5000);

switch(dw)

{

case WAIT_FAILED:

// Bad call to function (invalid handle?)

break;

case WAIT_TIMEOUT:

// None of the objects became signaled within 5000 milliseconds.

break;

case WAIT_OBJECT_0 + 0:

// The process identified by h[0] (hProcess1) terminated.

break;

case WAIT_OBJECT_0 + 1:

// The process identified by h[1] (hProcess2) terminated.

break;

case WAIT_OBJECT_0 + 2:

// The process identified by h[2] (hProcess3) terminated.

break;

}

如果为fWaitAll参数传递FALSE，WaitForMultipleObjects就从索引0开始向上对句柄数组进行扫描，同时已通知的第一个对象终止等待状态。这可能产生一些你不希望有的结果。例如，通过将3个进程句柄传递给该函数，你的线程就会等待3个子进程终止运行。如果数组中索引为0的进程终止运行，WaitForMultipleObjects就会返回。这时该线程就可以做它需要的任何事情，然后循环反复，等待另一个进程终止运行。如果该线程传递相同的3个句柄，该函数立即再次返回WAIT_OBJECT_0。除非删除已经收到通知的句柄，否则代码就无法正确地运行。

http://www.cnblogs.com/EmbeddedBoy/archive/2010/03/09/1681095.html

WaitForSingleObject   当指定的对象的状态被标记或者指定的时间间隔过完时，此函数返回DWORD类型参数。

　　格式：

　　　　DWORD WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);

　　参数：

　　　　hHandle表示对象的句柄

　　　　dwMilliseconds指出了时间间隔；过了指定的时间，即使对象状态没发生改变，函数也会返回；如果此参数设为0，函数测试对象的状态并且立即返回；如果此参数设为INFINITE，则表示此函数的时间间隔永远不会流逝完——只有等待对象状态被标识时返回。

　　返回值：

　　　　成功：WAIT_OBJECT_0：表示对象的状态被标识

　　　　　　   WAIT_TIMEOUT：表示指定时间已到而对象状态没有被标识

　　　　失败：WAIT_FAILED：表明失败

　　WaitForSingleObject 函数检查指定对象当前状态，如果对象的状态没有被标识，则调用的线程进入有效的等待状态。在等待对象状态被标识或者指定的时间间隔到期，线程只会占据(consume)处理器一小段时间。时间间隔需要被指定在0到0x7FFFFFFF之间的正数，最大的时间间隔值不等于无穷大而是0x7FFFFFFF，无穷大的时间间隔值是0xFFFFFFFF。任何在0x7FFFFFFF和0xFFFFFFFE之间的值都等同于0x7FFFFFFF；如果你需要一个时间间隔比0x7FFFFFFF还要大的话，使用表示不穷的值0xFFFFFFFF。

返回之前，等待函数修改了某些类型的同步对象的状态，只有当对象的信号状态引起了函数的返回时这种修改才发生。例如，一个信号量对象计数减少1。

WaitForSingleObject 函数能等待如下的各种对象：事件(Event)、线程(Thread)、进程(Process)、互斥量(Mutex)、信号量(Semaphore)。

使用时要小心调用等待函数和直接或间接产生窗口的代码。如果一个线程创建了窗口，那么它必须处理消息。广播消息发送到系统中的所有窗口。使用一个没有时间间隔的等待函数的线程可能导致系统死锁。例如，动态数据交换（DDE）协议和COM函数CoInitialize两个都间接地创建了可能导致死锁的窗口。因此，如果您有一个线程创建的窗口，使用MsgWaitForMultipleObjects 或者 MsgWaitForMultipleObjectsEx 而不是使用WaitForSingleObject。

/

http://blog.csdn.net/lyd_253261362/archive/2009/08/15/4450202.aspx

DWORD WaitForMultipleObjects(
  DWORD nCount,             // number of handles in the handle array
  CONST HANDLE *lpHandles,  // pointer to the object-handle array
  BOOL fWaitAll,            // wait flag
  DWORD dwMilliseconds      // time-out interval in milliseconds
);

其中参数

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) //所有事件发生

{

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

}

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

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

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

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

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

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

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

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

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

DWORD WINAPI ThreadProc(LPVOID lpParameter)
{
DWORD dwRet = 0;
int nIndex = 0;
while(1)
{dwRet = WaitForMultipleObjects(nCount,pHandles,false,INFINITE);
switch(dwRet)
{
case WAIT_TIMEOUT:
break;
case WAIT_FAILED:
return 1;
default:
{
nIndex = dwRet - WAIT_OBJECT_0;
ProcessHanlde(nIndex++); //同时检测其他的事件 while(nIndex < nCount)
{
dwRet = WaitForMultipleObjects(nCount - nIndex,&pHandles[nIndex],false,0);
switch(dwRet)
case WAIT_TIMEOUT:
nIndex = nCount; //退出检测,因为没有被触发的对象了.
break;
case WAIT_FAILED:
return 1;
default:
{ nIndex = dwRet - WAIT_OBJECT_0;
ProcessHanlde(nIndex++);
}
break;
}
}
}
break;
}
}
return 0;
}

http://www.51testing.com/?uid-68149-action-viewspace-itemid-73321

如果需要在一个线程中等待多个事件，则用WaitForMultipleObjects（）来等待。WaitForMultipleObjects（）与WaitForSingleObject（）类似，
同时监视位于句柄数组中的所有句柄。这些被监视对象的句柄享有平等的优先权，任何一个句柄都不可能比其他句柄具有更高的优先权。
WaitForMultipleObjects（）的函数原型为：

DWORD WaitForMultipleObjects(
　DWORD nCount, // 等待句柄数
　CONST HANDLE *lpHandles, // 句柄数组首地址
　BOOL fWaitAll, // 等待标志
　DWORD dwMilliseconds // 等待时间间隔
);

参数nCount指定了要等待的内核对象的数目，存放这些内核对象的数组由lpHandles来指向。fWaitAll对指定的这nCount个内核对象的两种等待方式
进行了指定，为TRUE时当所有对象都被通知时函数才会返回，为FALSE则只要其中任何一个得到通知就可以返回。dwMilliseconds在这里的作用与
在WaitForSingleObject（）中的作用是完全一致的。如果等待超时，函数将返回WAIT_TIMEOUT。如果返回WAIT_OBJECT_0到WAIT_OBJECT_0+nCount-1中的某个
值，则说明所有指定对象的状态均为已通知状态（当fWaitAll为TRUE时）或是用以减去WAIT_OBJECT_0而得到发生通知的对象的索引（当fWaitAll为FALSE时）。
如果返回值在WAIT_ABANDONED_0与WAIT_ABANDONED_0+nCount-1之间，则表示所有指定对象的状态均为已通知，且其中至少有一个对象是被丢弃的互斥对象
（当fWaitAll为TRUE时），或是用以减去WAIT_OBJECT_0表示一个等待正常结束的互斥对象的索引（当fWaitAll为FALSE时）。