具有互斥和semapohres的多线程程序

Question

There are 3 series' to compute using multithread.
To access a series you need to wait for semaphore, and after that you need to know if you are builder thread or cleaning thread.
Everything works great when I have num of threads which all of them has what to do and there are no 'floating' thread that cannot access semaphore or mutex.
If I do have too many threads and the dont have what to do the program get stuck unless after WaitSemRes/WaitMutexRes I kill that thread but I dont want to do that bc I loosing to much computing time. I just want them to keep waiting until they have something to do.
Am I missing something?

/* Thread is trying to enter specific series, if couldnt - try the next one*/

WaitSemRes = WaitForSingleObject(main_series[series_idx].semaphore, 0L);
    if (WaitSemRes == WAIT_OBJECT_0) {

        /* Check if i'm the cleaning thread */
        if (main_series[series_idx].ready_to_clean) {

            /* Catching series mutex to clean it alone */
            WaitMutexRes = WaitForSingleObject(main_series[series_idx].mutex, INFINITE);
            if (WaitMutexRes == WAIT_OBJECT_0) 
                // do something //
            }
            else {
                ExitThread(0);
            }

             // do stuff
    else {
        ExitThread(0);
    }

Answer 1

You could use a shutdown event to signalize the threads when there's no more work to be done, this way they can keep waiting indefinitely. It can be created using CreateEvent , then all you need to do is to make your worker threads wait upon it. When you all work is done you can make all threads exit almost simultaneously by using SetEvent, and then wait upon a HANDLE array that contains all the thread handles

For details regarding how to wait on multiple objects you can refer to WaitForMultipleObjects Example

Worker thread

int thread_function(...) {
[...]
    while(WaitForSingleObject(thread_shutdown_event, 0) != WAIT_OBJECT_0) {
        // Keep trying to process data until the event is signalized
    }
    // Exit thread
    return 0;
}

Pool handling functions

void end_thread_pool(...) {
    HANDLE wait_result;

    if(thread_shutdown_event == NULL)
        return;
    // Activate shutdown event
    SetEvent(thread_shutdown_event);
    // Wait upon thread handle list until all threads can return safely
    wait_result = (HANDLE)WaitForMultipleObjects(...);
    if(wait_result != WAIT_OBJECT_0) {
        // Failed to wait
    }
    CloseHandle(thread_shutdown_event);
[...]
    return;
}

void init_thread_pool(...) {
[...]
    thread_shutdown_event = CreateEvent(NULL, // Default security attributes
                                        TRUE, // Manual reset?
                                        FALSE,// Starting value
                                        TEXT("Thread Shutdown event"));// Event name
    if(thread_shutdown_event == NULL) {
        // Failed to create event
        return;
    }
    // Initiates threads and also puts their HANDLEs in a array
    // that is going to be used in end_thread_pool to wait
    // See 'WaitForMultipleObjects Example'
    thread_create(thread_function, number_of_threads);
[...]
    return;
}