Getting Started with QNX Neutrino - QNX Software Systems

More on synchronization
© 2009, QNX Software Systems GmbH & Co. KG.
Don’t be tricked by the prefix pthread_ into thinking that these are POSIX functions
— they’re not.
As described above, a thread needs to wait for something to happen. The most obvious
choice in the list of functions above is the pthread_sleepon_wait(). But first, the
thread needs to check if it really does have to wait. Let’s set up an example. One
thread is a producer thread that’s getting data from some piece of hardware. The other
thread is a consumer thread that’s doing some form of processing on the data that just
arrived. Let’s look at the consumer first:
volatile int data_ready = 0;
consumer ()
{
while (1) {
while (!data_ready) {
// WAIT
}
// process data
}
}
The consumer is sitting in its main processing loop (the while (1)); it’s going to do
its job forever. The first thing it does is look at the data_ready flag. If this flag is a 0,it
means there’s no data ready. Therefore, the consumer should wait. Somehow, the
producer will wake it up, at which point the consumer should reexamine its
data_ready flag. Let’s say that’s exactly what happens, and the consumer looks at the
flag and decides that it’s a 1, meaning data is now available. The consumer goes off
and processes the data, and then goes to see if there’s more work to do, and so on.
We’re going to run into a problem here. How does the consumer reset the data_ready
flag in a synchronized manner with the producer? Obviously, we’re going to need
some form of exclusive access to the flag so that only one of those threads is
modifying it at a given time. The method that’s used in this case is built with a mutex,
but it’s a mutex that’s buried in the implementation of the sleepon library, so we can
access it only via two functions: pthread_sleepon_lock() and
pthread_sleepon_unlock(). Let’s modify our consumer:
consumer ()
{
while (1) {
pthread_sleepon_lock ();
while (!data_ready) {
// WAIT
}
// process data
data_ready = 0;
pthread_sleepon_unlock ();
}
}
Now we’ve added the lock and unlock around the operation of the consumer. This
means that the consumer can now reliably test the data_ready flag, with no race
conditions, and also reliably set the flag.
60 Chapter 1 • Processes and Threads April 30, 2009