Getting Started with QNX Neutrino - QNX Software Systems

© 2009, QNX Software Systems GmbH & Co. KG. Threads and processes
This is exactly what happened with the graphics example. The main thread needs to
wait until all the worker threads have completed, and only then can the next part of the
program begin.
Note an important distinction, however. With pthread_join(), we’re waiting for the
termination of the threads. This means that the threads are no longer with us; they’ve
exited.
With the barrier, we’re waiting for a certain number of threads to rendezvous at the
barrier. Then, when the requisite number are present, we unblock all of them. (Note
that the threads continue to run.)
You first create a barrier with pthread_barrier_init():
#include
int
pthread_barrier_init (pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count);
This creates a barrier object at the passed address (pointer to the barrier object is in
barrier), with the attributes as specified by attr (we’ll just use NULL to get the
defaults). The number of threads that must call pthread_barrier_wait() is passed in
count.
Once the barrier is created, we then want each of the threads to call
pthread_barrier_wait() to indicate that it has completed:
#include
int
pthread_barrier_wait (pthread_barrier_t *barrier);
When a thread calls pthread_barrier_wait(), it will block until the number of threads
specified initially in the pthread_barrier_init() have called pthread_barrier_wait()
(and blocked too). When the correct number of threads have called
pthread_barrier_wait(), all those threads will “simultaneously” unblock.
Here’s an example:
/*
* barrier1.c
*/
#include
#include
#include
#include
pthread_barrier_t
barrier; // the barrier synchronization object
void *
thread1 (void *not_used)
{
time_t now;
char buf [27];
April 30, 2009 Chapter 1 • Processes and Threads 47