Getting Started with QNX Neutrino - QNX Software Systems

Process and thread fundamentals
© 2009, QNX Software Systems GmbH & Co. KG.
A semaphore with a count greater than 1
A semaphore as a mutex
• the door is unlocked and nobody is in the room
• the door is locked and one person is in the room
No other combination is possible — the door can’t be locked with nobody in the room
(how would we unlock it?), and the door can’t be unlocked with someone in the room
(how would they ensure their privacy?). This is an example of a semaphore with a
count of one — there can be at most only one person in that room, or one thread using
the semaphore.
The key here (pardon the pun) is the way we characterize the lock. In your typical
bathroom lock, you can lock and unlock it only from the inside — there’s no
outside-accessible key. Effectively, this means that ownership of the mutex is an
atomic operation — there’s no chance that while you’re in the process of getting the
mutex some other thread will get it, with the result that you both own the mutex. In
our house analogy this is less apparent, because humans are just so much smarter than
ones and zeros.
What we need for the kitchen is a different type of lock.
Suppose we installed the traditional key-based lock in the kitchen. The way this lock
works is that if you have a key, you can unlock the door and go in. Anyone who uses
this lock agrees that when they get inside, they will immediately lock the door from
the inside so that anyone on the outside will always require a key.
Well, now it becomes a simple matter to control how many people we want in the
kitchen — hang two keys outside the door! The kitchen is always locked. When
someone wants to go into the kitchen, they see if there’s a key hanging outside the
door. If so, they take it with them, unlock the kitchen door, go inside, and use the key
to lock the door.
Since the person going into the kitchen must have the key with them when they’re in
the kitchen, we’re directly controlling the number of people allowed into the kitchen at
any given point by limiting the number of keys available on the hook outside the door.
With threads, this is accomplished via a semaphore. A “plain” semaphore works just
like a mutex — you either own the mutex, in which case you have access to the
resource, or you don’t, in which case you don’t have access. The semaphore we just
described with the kitchen is a counting semaphore — it keeps track of the count (by
the number of keys available to the threads).
We just asked the question “Could you do it with a mutex?” in relation to
implementing a lock with a count, and the answer was no. How about the other way
around? Could we use a semaphore as a mutex?
Yes. In fact, in some operating systems, that’s exactly what they do — they don’t have
mutexes, only semaphores! So why bother with mutexes at all?
18 Chapter 1 • Processes and Threads April 30, 2009