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

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).