multithread program with mutexes and semapohres - c

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;
}