Getting Started with QNX Neutrino - QNX Software Systems

© 2009, QNX Software Systems GmbH & Co. KG. More on synchronization
it was told it could), it would use pthread_rwlock_rdlock(), and now it would block,
because the resource was no longer available in that mode. So, if we didn’t lock it if
we could, the thread that called the “try” version could still potentially block anyway!
Finally, regardless of the way that the lock was used, we need some way of releasing
the lock:
int
pthread_rwlock_unlock (pthread_rwlock_t *lock);
Once a thread has done whatever operation it wanted to do on the resource, it would
release the lock by calling pthread_rwlock_unlock(). If the lock is now available in a
mode that corresponds to the mode requested by another waiting thread, then that
thread would be made READY.
Note that we can’t implement this form of synchronization with just a mutex. The
mutex acts as a single-threading agent, which would be okay for the writing case
(where you want only one thread to be using the resource at a time) but would fall flat
in the reading case, because only one reader would be allowed. A semaphore couldn’t
be used either, because there’s no way to distinguish the two modes of access — a
semaphore would allow multiple readers, but if a writer were to acquire the
semaphore, as far as the semaphore is concerned this would be no different from a
reader acquiring it, and now you’d have the ugly situation of multiple readers and one
or more writers!
Sleepon locks
Another common situation that occurs in multithreaded programs is the need for a
thread to wait until “something happens.” This “something” could be anything! It
could be the fact that data is now available from a device, or that a conveyor belt has
now moved to the proper position, or that data has been committed to disk, or
whatever. Another twist to throw in here is that several threads may need to wait for
the given event.
To accomplish this, we’d use either a condition variable (which we’ll see next) or the
much simpler “sleepon” lock.
To use sleepon locks, you actually need to perform several operations. Let’s look at
the calls first, and then look at how you’d use the locks.
int
pthread_sleepon_lock (void);
int
pthread_sleepon_unlock (void);
int
pthread_sleepon_broadcast (void *addr);
int
pthread_sleepon_signal (void *addr);
int
pthread_sleepon_wait (void *addr);
April 30, 2009 Chapter 1 • Processes and Threads 59