Non-blocking pthread_join

Question

Is there a way of doing a non-blocking pthread_join? Some sort of timed join would be good to.

I'll try to clarify the question:

I'm coding the shutdown of a multithreaded server. If everything goes as it should all the threads exit by their own, but there's a small chance that a thread gets stuck.

In this case it would be convenient to have a non-blocking join so I could do something like this:

foreach thread do
  nb_pthread_join();
    if still running
      pthread_cancel();

I can think more cases where a a non-bloking join would be useful.

As it seems there is no such a function so I have already coded a workaround, but it's not as simple as I would like.

Answer 1

You could push a byte into a pipe opened as non-blocking to signal to the other thread when its done, then use a non-blocking read to check the status of the pipe.

Answer 2

The answer really depends on why you want to do this. If you just want to clean up dead threads, for example, it's probably easiest just to have a "dead thread cleaner" thread that loops and joins.

Answer 3

I'm not sure what exactly you mean, but I'm assuming that what you really need is a wait and notify mechanism.

In short, here's how it works: You wait for a condition to satisfy with a timeout. Your wait will be over if:

• The timeout occurs, or
• If the condition is satisfied.

You can have this in a loop and add some more intelligence to your logic. The best resource I've found for this related to Pthreads is this tutorial: POSIX Threads Programming (https://computing.llnl.gov/tutorials/pthreads/).

I'm also very surprised to see that there's no API for timed join in Pthreads.

Answer 4

There is no timed pthread_join, but if you are waiting for other thread blocked on conditions, you can use timed pthread_cond_timed_wait instead of pthread_cond_wait

Answer 5

If you're developing for QNX, you can use pthread_timedjoin() function.

Otherwise, you can create a separate thread that will perform pthread_join() and alert the parent thread, by signalling a semaphore for example, that the child thread completes. This separate thread can return what is gets from pthread_join() to let the parent thread determine not only when the child completes but also what value it returns.

Answer 6

As others have pointed out there is not a non-blocking pthread_join available in the standard pthread libraries.

However, given your stated problem (trying to guarantee that all of your threads have exited on program shutdown) such a function is not needed. You can simply do this:

int killed_threads = 0;
for(i = 0; i < num_threads; i++) {
   int return = pthread_cancel(threads[i]);
   if(return != ESRCH)
      killed_threads++;
}
if(killed_threads)
    printf("%d threads did not shutdown properly\n", killed_threads)
else
    printf("All threads exited successfully");

There is nothing wrong with calling pthread_cancel on all of your threads (terminated or not) so calling that for all of your threads will not block and will guarantee thread exit (clean or not).

That should qualify as a 'simple' workaround.

Answer 7

If you are running your application on linux, you may be interested to know that:

int pthread_tryjoin_np(pthread_t thread, void **retval);

int pthread_timedjoin_np(pthread_t thread, void **retval,
                                const struct timespec *abstime);

Be careful, as the suffix suggests it, "np" means "non portable". They are not posix standard, gnu extensions, useful tough.

link to man page