WaitForSingleObject and WaitForMultipleObjects equivalent in linux

Question

Hi,

I am migrating an applciation from windows to linux. I am facing problem w.r.t WaitForSingleObject and WaitForMultipleObjects interfaces

In my application I spawn multiple threads where all threads wait for events from parent process or periodically run for every t seconds.

How can I implement this in Unix.

I have checked pthread_cond_timedwait, but we have to specify absolute time for this.

Answer 1

Stick to pthread_cond_timedwait and use clock_gettime. For example:

struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += 10; // ten seconds
while (!some_condition && ret == 0)
    ret = pthread_cond_timedwait(&cond, &mutex, &ts);

Wrap it in a function if you wish.

---

UPDATE: complementing the answer based on our comments.

POSIX doesn't have a single API to wait for "all types" of events/objects as Windows does. Each one has its own functions. The simplest way to notify a thread for termination is using atomic variables/operations. For example:

Main thread:

// Declare it globally (argh!) or pass by argument when the thread is created
atomic_t must_terminate = ATOMIC_INIT(0);

// "Signal" termination by changing the initial value
atomic_inc(&must_terminate); 

Secondary thread:

// While it holds the default value
while (atomic_read(&must_terminate) == 0) {
    // Keep it running...
}
// Do proper cleanup, if needed
// Call pthread_exit() providing the exit status

Another alternative is to send a cancellation request using pthread_cancel. The thread being cancelled must have called pthread_cleanup_push to register any necessary cleanup handler. These handlers are invoked in the reverse order they were registered. Never call pthread_exit from a cleanup handler, because it's undefined behaviour. The exit status of a cancelled thread is PTHREAD_CANCELED. If you opt for this alternative, I recommend you to read mainly about cancellation points and types.

And last but not least, calling pthread_join will make the current thread block until the thread passed by argument terminates. As bonus, you'll get the thread's exit status.

Answer 2

A more Unix-y approach may be to fork instead of thread (call fork enough times so you have enough children), and use waitpid to wait for child processes. You can use waitpid to check the status of all children or specific children, and you can use any suitable sleep function (sleep, usleep etc) to get the timeout part of WaitForSingleObject. You can kill any child by using the kill function.

The child created by fork could just call the same function that's passed to CreateThread (or the pthread equivalent).