转：WaitForSingleObject()函数、WaitForMultipleObject()函数

http://blog.csdn.net/xiaobai1593/article/details/6672193

在多线程下面，有时候我们会希望等待某一线程完成了再继续做其他事情，要实现这个目的，可以使用Windows API函数WaitForSingleObject，或者WaitForMultipleObjects。这两个函数都会等待Object被标为有信号(signaled)时才返回的。
那么，什么是信号呢？
简单来说，Windows下创建的Object都会被赋予一个状态量。如果Object被激活了，或者正在使用，那么该Object就是无信号，也就是不可用；另一方面，如果Object可用了，那么它就恢复有信号了。

这两个函数的优点是它们在等待的过程中会进入一个非常高效沉睡状态，只占用极少的CPU时间片。（这两个函数都是在内核状态下等待内核对象，不切换到用户模式下，因而效率很高）

WaitForSingleObject()

1. 格式

DWORD WaitForSingleObject( HANDLE hHandle, DWORDdwMilliseconds);

有两个参数，分别是THandle和Timeout(毫秒单位)。

如果想要等待一条线程，那么你需要指定线程的Handle，以及相应的Timeout时间。当然，如果你想无限等待下去，Timeout参数可以指定系统常量INFINITE。

2. 使用对象

它可以等待如下几种类型的对象：

Event，Mutex，Semaphore，Process，Thread 

3. 返回类型

有三种返回类型：

WAIT_OBJECT_0, 表示等待的对象有信号（对线程来说，表示执行结束）；

 WAIT_TIMEOUT, 表示等待指定时间内，对象一直没有信号（线程没执行完）；

WAIT_ABANDONED 表示对象有信号，但还是不能执行  一般是因为未获取到锁或其他原因

示例：

<span style="font-family:Times New Roman;">#include <windows.h>
#include <stdio.h>
#include <iostream.h>

//声明函数  创建线程
DWORD WINAPI FunProc( LPVOID lpParameter);

void main()
{
    HANDLE hThread;
    hThread=CreateThread(NULL,0,FunProc,NULL,0,NULL);
    DWORD dwRet=WaitForSingleObject(hThread, 1);
    if(dwRet==WAIT_OBJECT_0)
    {
        printf("创建的线程执行结束
");
    }
    if(dwRet==WAIT_TIMEOUT)
    {
        printf("等待超时
");
    }
    if(dwRet==WAIT_ABANDONED)
    {
        printf("Abandoned
");
    }
    CloseHandle(hThread);
}

DWORD WINAPI FunProc( LPVOID lpParameter )
{
    int i=1;
    for(; i<1000; i++)
    {
        printf("%d  ", i);
        if(! (i%10))
            printf("
");
    }
    return 0;
}</span>

WaitForMultipleObjecct

相对来说，WaitForMultipleObjects要复杂点点

格式为：

DWORD WaitForMultipleObjects(DWORD nCount, CONST HANDLE *lpHandles, BOOLfWaitAll, DWORDdwMilliseconds);

四个参数分别是：

1. nCount，DWORD类型，用于指定句柄数组的数量
2. lphObjects，Pointer类型，用于指定句柄数组的内存地址
3. fWaitAll，Boolean类型，True表示函数等待所有指定句柄的Object有信号为止
4. dwTimeout，DWORD类型，用于指定等待的Timeout时间，单位毫秒，可以是INFINITE

当WaitForMultipleObjects等待多个内核对象的时候，如果它的bWaitAll 参数设置为false。其返回值减去WAIT_OBJECT_0 就是参数lpHandles数组的序号。如果同时有多个内核对象被触发，这个函数返回的只是其中序号最小的那个。

如果为TRUE 则等待所有信号量有效在往下执行。（FALSE 当有其中一个信号量有效时就向下执行）

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

举个例子：我们需要在一个线程中处理从完成端口、数据库、和可等待定时器来的数据。一个典型的实现方法就是：用WaitForMultipleObjects等待所有的这些事件。如果完成端口，数据库发过来的数据量非常大，可等待定时器时间也只有几十毫秒。那么这些事件同时触发的几率可以说非常大，我们不希望丢弃任何一个被触发的事件。那么如何能高效地实现这一处理呢？ 　　

MSDN中有一句非常重要的描述，它可以说是WaitForMultipleObjects用法的精髓：The function modifies the state of some types of synchronization objects. Modification occurs only for the object or objects whose signaled state caused the function to return. For example, the count of a semaphore object is decreased by one. When bWaitAll is FALSE, and multiple objects are in the signaled state, the function chooses one of the objects to satisfy the wait; the states of the objects not selected are unaffected. 　　

多个内核对象被触发时，WaitForMultipleObjects选择其中序号最小的返回。而WaitForMultipleObjects它只会改变使它返回的那个内核对象的状态。

这儿又会产生一个问题，如果序号最小的那个对象频繁被触发，那么序号比它大的内核对象将得不到被处理的机会。为了解决这一问题，可以采用双WaitForMultipleObjects检测机制来实现。见下面的例子： 

<span style="font-family:Times New Roman;">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) //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;
                    }//switch结束
                }//while结束
            }//default结束
                break;
        }//switch结束

    }//while结束
    return 0;
}</span>

MSDN对于这个函数的返回值还有一句话： 　　

Return Values 　　If the function succeeds, the return value indicates the event that caused the function to return. This value can be one of the following. 　　ValueMeaning 　　WAIT_OBJECT_0 to (WAIT_OBJECT_0 + nCount – 1)If bWaitAll is TRUE, the return value indicates that the state of all specified objects is signaled. 　　If bWaitAll is FALSE, the return value minus WAIT_OBJECT_0 indicates the lpHandles array index of the object that satisfied the wait. If more than one object became signalled during the call, this is the array index of the signalled object with the smallest index value of all the signalled objects. 　　WAIT_ABANDONED_0 to (WAIT_ABANDONED_0 + nCount – 1)If bWaitAll is TRUE, the return value indicates that the state of all specified objects is signaled and at least one of the objects is an abandoned mutex object. 　　If bWaitAll is FALSE, the return value minus WAIT_ABANDONED_0 indicates the lpHandles array index of an abandoned mutex object that satisfied the wait. 　　WAIT_TIMEOUTThe time-out interval elapsed and the conditions specified by the bWaitAll parameter are not satisfied. 　　

返回值

如果函数成功，返回值表示该事件导致该函数返回。

这个值可以是下列之一：

WAIT_OBJECT_0到WAIT_OBJECT_0 + nCount - 1

      如果bWaitAll为TRUE，则返回值表明所有指定对象的状态信号

      如果bWaitAll为FALSE，则返回值减去不是WAIT_OBJECT_0表示lpHandles数组的对象的满意指数的等待。如果多个对象在通话过程中信号成为有信号状态，这是与所有的信号对象的最小索引值的信号对象的数组索引。

WAIT_ABANDONED_0至WAIT_ABANDONED_0 + nCount - 1

     如果bWaitAll为TRUE，则返回值表明所有指定对象的状态，至少是暗示的对象之一，是一个废弃的互斥对象。 

     如果bWaitAll为FALSE，则返回值减去WAIT_ABANDONED_0表示lpHandles数组的一个废弃的互斥对象的满意指数的等待。 　　

WAIT_TIMEOUTThe超时间隔已过，由bWaitAll参数指定的条件得不到满足。