Behavior of WaitForMultipleObjects when multiple handles signal at the same time.

Question

Given: I fill up an array of handles with auto reset events and pass it off to WaitForMultipleObjects with bWaitAll = FALSE.

From MSDN: “When bWaitAll is FALSE, this function checks the handles in the array in order starting with index 0, until one of the objects is signaled. If multiple objects become signaled, the function returns the index of the first handle in the array whose object was signaled.”

So, now if multiple objects signal I’ll get the index of the first one. Do I have to loop though my array to see if any others have signaled?

Right now I have a loop that’s along the lines of:

For ( ; ; )
{
WaitForMultipleObjects(…)
If  (not failed)
     Process object that called. 
     Remove the handle that signaled from the array.
     Compact the arrary.
}

Answer 1

Yes. One alternative would be that you could do WaitForSingleObject(handle, 0) on each handle which will return immediately and indicate if they are signaled or not.

EDIT: Here's sample pseudocode for what I mean:

ret = WaitForMultipleObjects()
if (ret >= WAIT_OBJECT_0 && ret <= WAIT_OBJECT_0 + (count - 1))
{
    firstSignaled = ret - WAIT_OBJECT_0;
    for (i = firstSignaled + 1; i < count; i++)
    {
        if (WaitForSingleObject(handles[i], 0) == WAIT_OBJECT_0)
        {
           // Signaled!
        }
    }
}

Answer 2

One other option you might have is to use RegisterWaitForSingleObject. The idea is that youyou flag the signalled state of event in a secondary array from the callback function and then signal a master event which is used to wake up your primary thread (which calls WaitForSingleObject on the master event).

Obviously you'd have to take care to ensure that the secondary array was protected from access by the main thread but it would work.

Answer 3

So, now if multiple objects signal I’ll get the index of the first one. Do I have to loop though my array to see if any others have signaled?

Why not just go back round into the Wait()? if multiple objects signalled, they will still be signalled when you come back round. Of course, if you have a very rapidly firing first object in the wait object array, it will starve the others; what you do is order your objects in the wait object array by frequency of firing, with the least frequent being first.

BTW, where you're using an endless for(), you could use a goto. If you really are not leaving a loop, an unconditional goto most properly expresses your intent.