Getting Started with QNX Neutrino - QNX Software Systems

© 2009, QNX Software Systems GmbH & Co. KG. Threads and processes
Synchronizing to the termination of a thread
I mentioned that there were a number of problems with the simplistic code sample
initially shown. Another problem with it is that main() starts up a bunch of threads and
then displays the results. How does the function know when it’s safe to display the
results?
To have the main() function poll for completion would defeat the purpose of a realtime
operating system:
int
main (int argc, char **argv)
{
...
// start threads as before
}
while (num_lines_completed < num_x_lines) {
sleep (1);
}
Don’t even consider writing code like this!
There are two elegant solutions to this problem: pthread_join() and
pthread_barrier_wait().
Joining
The simplest method of synchronization is to join the threads as they terminate.
Joining really means waiting for termination.
Joining is accomplished by one thread waiting for the termination of another thread.
The waiting thread calls pthread_join():
#include
int
pthread_join (pthread_t thread, void **value_ptr);
To use pthread_join(), you pass it the thread ID of the thread that you wish to join, and
an optional value_ptr, which can be used to store the termination return value from the
joined thread. (You can pass in a NULL if you aren’t interested in this value — we’re
not, in this case.)
Where did the thread ID came from? We ignored it in the pthread_create() —we
passed in a NULL for the first parameter. Let’s now correct our code:
int num_lines_per_cpu, num_cpus;
int main (int argc, char **argv)
{
int cpu;
pthread_t *thread_ids;
... // perform initializations
thread_ids = malloc (sizeof (pthread_t) * num_cpus);
April 30, 2009 Chapter 1 • Processes and Threads 45