What shall I do while waiting in a thread.

Question

I have a main program which creates a collection of N child threads to perform some calculations. Each child is going to be fully occupied on their tasks from the moment their threads are created till the moment they have finished. The main program will also create a special (N+1)th thread which has some intermittent tasks to perform. When certain conditions are met (like a global variable takes on a certain value) the special thread will perform a calculation and then go back to waiting for those conditions to be met again. It is vital that when the N+1th thread has nothing to do, it should not slow down the other processors. Can someone suggest how to achieve this.

EDIT: The obvious but clumsy way would be like this:

// inside one of the standard worker child threads...
if (time_for_one_of_those_intermittent_calculations_to_be_done())
{
    global_flag_set = TRUE;
}

and

// inside the special (N+1)th thread
for(;;)
{
    if (global_flag_set == TRUE)
    {
        perform_big_calculation();
        global_flag_set = FALSE;
    }
    // sleep for a while?
}

Answer 1

Yes. Use condition variables. If you sleep on a condition variable, the thread will be removed from the runqueue until the condition variable has been signaled.

Answer 2

You should check out the WaitForSingleObject and WaitForMultipleObjects functions in the Windows API.

WaitForMultipleObjects

Answer 3

You should use Windows synchronization events for this, so your thread is doing nothing while waiting. See MSDN for more info; I'd start with CreateEvent(), and then go to the rest of the Event-related functions here for OpenEvent(), PulseEvent(), SetEvent() and ResetEvent().

And, of course, WaitForSingleObject() or WaitForMultipleObjects(), as pointed out by mrduclaw in the comment below.

Answer 4

A ready-to-use condition class for WIN32 ;)

class Condition {
private:
    HANDLE m_condition;
    Condition( const Condition& ) {} // non-copyable
public:
    Condition() {
        m_condition = CreateEvent( NULL, TRUE, FALSE, NULL );
    }
    ~Condition() {
        CloseHandle( m_condition );
    }
    void Wait() {
        WaitForSingleObject( m_condition, INFINITE );
        ResetEvent( m_condition );
    }
    bool Wait( uint32 ms ) {
        DWORD result = WaitForSingleObject( m_condition, (DWORD)ms );
        ResetEvent( m_condition );
        return result == WAIT_OBJECT_0;
    }
    void Signal() {
        SetEvent( m_condition );
    }
};

Usage:

// inside one of the standard worker child threads...
if( time_for_one_of_those_intermittent_calculations_to_be_done() ) {
    global_flag_set = TRUE;
    condition.Signal();
}


// inside the special (N+1)th thread
for(;;) {
    if( global_flag_set==FALSE ) {
        condition.Wait(); // sends thread to sleep, until signalled
    }
    if (global_flag_set == TRUE) {
        perform_big_calculation();
        global_flag_set = FALSE;
    }
}

NOTE: you have to add a lock (e.g. a critical section) around global_flag_set. And also in most cases the flag should be replaced with a queue or at least a counter (a thread could signal multiple times while 'special' thread is performing its calculations).

Answer 5

Lacking the more preferred options already given, I generally just yield the CPU in a loop until the desired condition is met.

Answer 6

Basically, you have two possibilities for your N+1th thread.

• If its work is rare, the best thing to do is simply to ask it to sleep, and wake it up on demand. Rare context switches are insignificants.
• If it has to work often, then you may need to spinlock it, that is, a busy waiting state that prevent it from being rescheduled, or switched.