Transcript of "downey08semaphores.pdf"

1.
The Little Book of Semaphores
Allen B. Downey
Version 2.1.5

2.
2
The Little Book of Semaphores
Second Edition
Version 2.1.5
Copyright 2005, 2006, 2007, 2008 Allen B. Downey
Permission is granted to copy, distribute and/or modify this document under
the terms of the GNU Free Documentation License, Version 1.1 or any later ver-
sion published by the Free Software Foundation; this book contains no Invariant
Sections, no Front-Cover Texts, and no Back-Cover Texts.
You can obtain a copy of the GNU Free Documentation License from
www.gnu.org or by writing to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA.
The original form of this book is LaTeX source code. Compiling this LaTeX
source has the eﬀect of generating a device-independent representation of a
book, which can be converted to other formats and printed.
This book was typeset by the author using latex, dvips and ps2pdf, among
other free, open-source programs. The LaTeX source for this book is available
from http://greenteapress.com/semaphores.

3.
Preface
Most undergraduate Operating Systems textbooks have a module on Synchro-
nization, which usually presents a set of primitives (mutexes, semaphores, mon-
itors, and sometimes condition variables), and classical problems like readers-
writers and producers-consumers.
When I took the Operating Systems class at Berkeley, and taught it at Colby
College, I got the impression that most students were able to understand the
solutions to these problems, but few would have been able to produce them, or
solve similar problems.
One reason students don’t understand this material deeply is that it takes
more time, and more practice, than most classes can spare. Synchronization is
just one of the modules competing for space in an Operating Systems class, and
I’m not sure I can argue that it is the most important. But I do think it is one
of the most challenging, interesting, and (done right) fun.
I wrote the ﬁrst edition this book with the goal of identifying synchronization
idioms and patterns that could be understood in isolation and then assembled
to solve complex problems. This was a challenge, because synchronization code
doesn’t compose well; as the number of components increases, the number of
interactions grows unmanageably.
Nevertheless, I found patterns in the solutions I saw, and discovered at
least some systematic approaches to assembling solutions that are demonstrably
correct.
I had a chance to test this approach when I taught Operating Systems at
Wellesley College. I used the ﬁrst edition of The Little Book of Semaphores
along with one of the standard textbooks, and I taught Synchronization as a
concurrent thread for the duration of the course. Each week I gave the students
a few pages from the book, ending with a puzzle, and sometimes a hint. I told
them not to look at the hint unless they were stumped.
I also gave them some tools for testing their solutions: a small magnetic
whiteboard where they could write code, and a stack of magnets to represent
the threads executing the code.
The results were dramatic. Given more time to absorb the material, stu-
dents demonstrated a depth of understanding I had not seen before. More
importantly, most of them were able to solve most of the puzzles. In some
cases they reinvented classical solutions; in other cases they found creative new
approaches.

4.
ii Preface
When I moved to Olin College, I took the next step and created a half-class,
called Synchronization, which covered The Little Book of Semaphores and also
the implementation of synchronization primitives in x86 Assembly Language,
POSIX, and Python.
The students who took the class helped me ﬁnd errors in the ﬁrst edition and
several of them contributed solutions that were better than mine. At the end of
the semester, I asked each of them to write a new, original problem (preferably
with a solution). I have added their contributions to the second edition.
Also since the ﬁrst edition appeared, Kenneth Reek presented the article
“Design Patterns for Semaphores” at the ACM Special Interest Group for Com-
puter Science Education. He presents a problem, which I have cast as the Sushi
Bar Problem, and two solutions that demonstrate patterns he calls “Pass the
baton” and “I’ll do it for you.” Once I came to appreciate these patterns, I was
able to apply them to some of the problems from the ﬁrst edition and produce
solutions that I think are better.
One other change in the second edition is the syntax. After I wrote the ﬁrst
edition, I learned Python, which is not only a great programming language; it
also makes a great pseudocode language. So I switched from the C-like syntax
in the ﬁrst edition to syntax that is pretty close to executable Python1 . In fact,
I have written a simulator that can execute many of the solutions in this book.
Readers who are not familiar with Python will (I hope) ﬁnd it mostly ob-
vious. In cases where I use a Python-speciﬁc feature, I explain the syntax and
what it means. I hope that these changes make the book more readable.
The pagination of this book might seem peculiar, but there is a method to
my whitespace. After each puzzle, I leave enough space that the hint appears
on the next sheet of paper and the solution on the next sheet after that. When
I use this book in my class, I hand it out a few pages at a time, and students
collect them in a binder. My pagination system makes it possible to hand out
a problem without giving away the hint or the solution. Sometimes I fold and
staple the hint and hand it out along with the problem so that students can
decide whether and when to look at the hint. If you print the book single-sided,
you can discard the blank pages and the system still works.
This is a Free Book, which means that anyone is welcome to read, copy,
modify and redistribute it, subject to the restrictions of the license, which is the
GNU Free Documentation License. I hope that people will ﬁnd this book useful,
but I also hope they will help continue to develop it by sending in corrections,
suggestions, and additional material. Thanks!
Allen B. Downey
Needham, MA
June 1, 2005
1 The primary diﬀerence is that I sometimes use indentation to indicate code that is pro-
tected by a mutex, which would cause syntax errors in Python.

5.
iii
Contributor’s list
The following are some of the people who have contributed to this book:
• Many of the problems in this book are variations of classical problems
that appeared ﬁrst in technical articles and then in textbooks. Whenever
I know the origin of a problem or solution, I acknowledge it in the text.
• I also thank the students at Wellesley College who worked with the ﬁrst
edition of the book, and the students at Olin College who worked with
the second edition.
• Se Won sent in a small but important correction in my presentation of
Tanenbaum’s solution to the Dining Philosophers Problem.
• Daniel Zingaro punched a hole in the Dancer’s problem, which provoked
me to rewrite that section. I can only hope that it makes more sense now.
Daniel also pointed out an error in a previous version of my solution to
the H2 O problem, and then wrote back a year later with some typos.
• Thomas Hansen found a typo in the Cigarette smokers problem.
• Pascal R¨tten pointed out several typos, including my embarrassing mis-
u
spelling of Edsger Dijkstra.
• Marcelo Johann pointed out an error in my solution to the Dining Savages
problem, and ﬁxed it!
• Roger Shipman sent a whole passel of corrections as well as an interesting
variation on the Barrier problem.
• Jon Cass pointed out an omission in the discussion of dining philosophers.
• Krzysztof Ko´ciuszkiewicz sent in several corrections, including a missing
s
line in the Fifo class deﬁnition.
• Fritz Vaandrager at the Radboud University Nijmegen in the Netherlands
and his students Marc Schoolderman, Manuel Stampe and Lars Lockefeer
used a tool called UPPAAL to check several of the solutions in this book
and found errors in my solutions to the Room Party problem and the
Modus Hall problem.
• Eric Gorr pointed out an explanation in Chapter 3 that was not exactly
right.
• Jouni Lepp¨j¨rvi helped clarify the origins of semaphores.
aa
• Christoph Bartoschek found an error in a solution to the exclusive dance
problem.
• Eus found a typo in Chapter 3.

6.
iv Preface
• Tak-Shing Chan found an out-of-bounds error in counter mutex.c.
• Roman V. Kiseliov made several suggestions for improving the appearance
of the book, and helped me with some L TEX issues.
A
• Alejandro C´spedes is working on the Spanish translation of this book and
e
found some typos.
• Erich Nahum found a problem in my adaptation of Kenneth Reek’s solu-
tion to the Sushi Bar Problem.
• Martin Storsj¨ sent a correction to the generalized smokers problem.
o

13.
Chapter 1
Introduction
1.1 Synchronization
In common use, “synchronization” means making two things happen at the
same time. In computer systems, synchronization is a little more general; it
refers to relationships among events—any number of events, and any kind of
relationship (before, during, after).
Computer programmers are often concerned with synchronization con-
straints, which are requirements pertaining to the order of events. Examples
include:
Serialization: Event A must happen before Event B.
Mutual exclusion: Events A and B must not happen at the same time.
In real life we often check and enforce synchronization constraints using a
clock. How do we know if A happened before B? If we know what time both
events occurred, we can just compare the times.
In computer systems, we often need to satisfy synchronization constraints
without the beneﬁt of a clock, either because there is no universal clock, or
because we don’t know with ﬁne enough resolution when events occur.
That’s what this book is about: software techniques for enforcing synchro-
nization constraints.
1.2 Execution model
In order to understand software synchronization, you have to have a model of
how computer programs run. In the simplest model, computers execute one
instruction after another in sequence. In this model, synchronization is trivial;
we can tell the order of events by looking at the program. If Statement A comes
before Statement B, it will be executed ﬁrst.

14.
2 Introduction
There are two ways things get more complicated. One possibility is that
the computer is parallel, meaning that it has multiple processors running at the
same time. In that case it is not easy to know if a statement on one processor
is executed before a statement on another.
Another possibility is that a single processor is running multiple threads of
execution. A thread is a sequence of instructions that execute sequentially. If
there are multiple threads, then the processor can work on one for a while, then
switch to another, and so on.
In general the programmer has no control over when each thread runs; the
operating system (speciﬁcally, the scheduler) makes those decisions. As a result,
again, the programmer can’t tell when statements in diﬀerent threads will be
executed.
For purposes of synchronization, there is no diﬀerence between the parallel
model and the multithread model. The issue is the same—within one processor
(or one thread) we know the order of execution, but between processors (or
threads) it is impossible to tell.
A real world example might make this clearer. Imagine that you and your
friend Bob live in diﬀerent cities, and one day, around dinner time, you start to
wonder who ate lunch ﬁrst that day, you or Bob. How would you ﬁnd out?
Obviously you could call him and ask what time he ate lunch. But what if
you started lunch at 11:59 by your clock and Bob started lunch at 12:01 by his
clock? Can you be sure who started ﬁrst? Unless you are both very careful to
keep accurate clocks, you can’t.
Computer systems face the same problem because, even though their clocks
are usually accurate, there is always a limit to their precision. In addition,
most of the time the computer does not keep track of what time things happen.
There are just too many things happening, too fast, to record the exact time of
everything.
Puzzle: Assuming that Bob is willing to follow simple instructions, is there
any way you can guarantee that tomorrow you will eat lunch before Bob?

15.
1.3 Serialization with messages 3
1.3 Serialization with messages
One solution is to instruct Bob not to eat lunch until you call. Then, make
sure you don’t call until after lunch. This approach may seem trivial, but the
underlying idea, message passing, is a real solution for many synchronization
problems. At the risk of belaboring the obvious, consider this timeline.
You Bob
a1 Eat breakfast b1 Eat breakfast
a2 Work b2 Wait for a call
a3 Eat lunch b3 Eat lunch
a4 Call Bob
The ﬁrst column is a list of actions you perform; in other words, your thread
of execution. The second column is Bob’s thread of execution. Within a thread,
we can always tell what order things happen. We can denote the order of events
a1 < a2 < a3 < a4
b1 < b2 < b3
where the relation a1 < a2 means that a1 happened before a2.
In general, though, there is no way to compare events from diﬀerent threads;
for example, we have no idea who ate breakfast ﬁrst (is a1 < b1?).
But with message passing (the phone call) we can tell who ate lunch ﬁrst
(a3 < b3). Assuming that Bob has no other friends, he won’t get a call until
you call, so b2 > a4 . Combining all the relations, we get
b3 > b2 > a4 > a3
which proves that you had lunch before Bob.
In this case, we would say that you and Bob ate lunch sequentially, because
we know the order of events, and you ate breakfast concurrently, because we
don’t.
When we talk about concurrent events, it is tempting to say that they happen
at the same time, or simultaneously. As a shorthand, that’s ﬁne, as long as you
remember the strict deﬁnition:
Two events are concurrent if we cannot tell by looking at the program
which will happen ﬁrst.
Sometimes we can tell, after the program runs, which happened ﬁrst, but
often not, and even if we can, there is no guarantee that we will get the same
result the next time.

16.
4 Introduction
1.4 Non-determinism
Concurrent programs are often non-deterministic, which means it is not pos-
sible to tell, by looking at the program, what will happen when it executes.
Here is a simple example of a non-deterministic program:
Thread A Thread B
a1 print "yes" b1 print "no"
Because the two threads run concurrently, the order of execution depends
on the scheduler. During any given run of this program, the output might be
“yes no” or “no yes”.
Non-determinism is one of the things that makes concurrent programs hard
to debug. A program might work correctly 1000 times in a row, and then crash
on the 1001st run, depending on the particular decisions of the scheduler.
These kinds of bugs are almost impossible to ﬁnd by testing; they can only
be avoided by careful programming.
1.5 Shared variables
Most of the time, most variables in most threads are local, meaning that they
belong to a single thread and no other threads can access them. As long as
that’s true, there tend to be few synchronization problems, because threads
just don’t interact.
But usually some variables are shared among two or more threads; this
is one of the ways threads interact with each other. For example, one way
to communicate information between threads is for one thread to read a value
written by another thread.
If the threads are unsynchronized, then we cannot tell by looking at the
program whether the reader will see the value the writer writes or an old value
that was already there. Thus many applications enforce the constraint that
the reader should not read until after the writer writes. This is exactly the
serialization problem in Section 1.3.
Other ways that threads interact are concurrent writes (two or more writ-
ers) and concurrent updates (two or more threads performing a read followed
by a write). The next two sections deal with these interactions. The other
possible use of a shared variable, concurrent reads, does not generally create a
synchronization problem.
1.5.1 Concurrent writes
In the following example, x is a shared variable accessed by two writers.
Thread A Thread B
a1 x = 5 b1 x = 7
a2 print x

17.
1.5 Shared variables 5
What value of x gets printed? What is the ﬁnal value of x when all these
statements have executed? It depends on the order in which the statements are
executed, called the execution path. One possible path is a1 < a2 < b1, in
which case the output of the program is 5, but the ﬁnal value is 7.
Puzzle: What path yields output 5 and ﬁnal value 5?
Puzzle: What path yields output 7 and ﬁnal value 7?
Puzzle: Is there a path that yields output 7 and ﬁnal value 5? Can you
prove it?
Answering questions like these is an important part of concurrent program-
ming: What paths are possible and what are the possible eﬀects? Can we prove
that a given (desirable) eﬀect is necessary or that an (undesirable) eﬀect is
impossible?
1.5.2 Concurrent updates
An update is an operation that reads the value of a variable, computes a new
value based on the old value, and writes the new value. The most common kind
of update is an increment, in which the new value is the old value plus one. The
following example shows a shared variable, count, being updated concurrently
by two threads.
Thread A Thread B
a1 count = count + 1 b1 count = count + 1
At ﬁrst glance, it is not obvious that there is a synchronization problem here.
There are only two execution paths, and they yield the same result.
The problem is that these operations are translated into machine language
before execution, and in machine language the update takes two steps, a read
and a write. The problem is more obvious if we rewrite the code with a tempo-
rary variable, temp.
Thread A Thread B
a1 temp = count b1 temp = count
a2 count = temp + 1 b2 count = temp + 1
Now consider the following execution path
a1 < b1 < b2 < a2
Assuming that the initial value of x is 0, what is its ﬁnal value? Because
both threads read the same initial value, they write the same value. The variable
is only incremented once, which is probably not what the programmer had in
mind.
This kind of problem is subtle because it is not always possible to tell, look-
ing at a high-level program, which operations are performed in a single step and
which can be interrupted. In fact, some computers provide an increment in-
struction that is implemented in hardware cannot be interrupted. An operation
that cannot be interrupted is said to be atomic.

18.
6 Introduction
So how can we write concurrent programs if we don’t know which operations
are atomic? One possibility is to collect speciﬁc information about each opera-
tion on each hardware platform. The drawbacks of this approach are obvious.
The most common alternative is to make the conservative assumption that
all updates and all writes are not atomic, and to use synchronization constraints
to control concurrent access to shared variables.
The most common constraint is mutual exclusion, or mutex, which I men-
tioned in Section 1.1. Mutual exclusion guarantees that only one thread accesses
a shared variable at a time, eliminating the kinds of synchronization errors in
this section.
1.5.3 Mutual exclusion with messages
Like serialization, mutual exclusion can be implemented using message passing.
For example, imagine that you and Bob operate a nuclear reactor that you
monitor from remote stations. Most of the time, both of you are watching for
warning lights, but you are both allowed to take a break for lunch. It doesn’t
matter who eats lunch ﬁrst, but it is very important that you don’t eat lunch
at the same time, leaving the reactor unwatched!
Puzzle: Figure out a system of message passing (phone calls) that enforces
these restraints. Assume there are no clocks, and you cannot predict when lunch
will start or how long it will last. What is the minimum number of messages
that is required?

19.
Chapter 2
Semaphores
In real life a semaphore is a system of signals used to communicate visually,
usually with ﬂags, lights, or some other mechanism. In software, a semaphore is
a data structure that is useful for solving a variety of synchronization problems.
Semaphores were invented by Edsger Dijkstra, a famously eccentric com-
puter scientist. Some of the details have changed since the original design, but
the basic idea is the same.
2.1 Deﬁnition
A semaphore is like an integer, with three diﬀerences:
1. When you create the semaphore, you can initialize its value to any integer,
but after that the only operations you are allowed to perform are increment
(increase by one) and decrement (decrease by one). You cannot read the
current value of the semaphore.
2. When a thread decrements the semaphore, if the result is negative, the
thread blocks itself and cannot continue until another thread increments
the semaphore.
3. When a thread increments the semaphore, if there are other threads wait-
ing, one of the waiting threads gets unblocked.
To say that a thread blocks itself (or simply “blocks”) is to say that it notiﬁes
the scheduler that it cannot proceed. The scheduler will prevent the thread from
running until an event occurs that causes the thread to become unblocked. In
the tradition of mixed metaphors in computer science, unblocking is often called
“waking”.
That’s all there is to the deﬁnition, but there are some consequences of the
deﬁnition you might want to think about.

20.
8 Semaphores
• In general, there is no way to know before a thread decrements a
semaphore whether it will block or not (in speciﬁc cases you might be
able to prove that it will or will not).
• After a thread increments a semaphore and another thread gets woken
up, both threads continue running concurrently. There is no way to know
which thread, if either, will continue immediately.
• When you signal a semaphore, you don’t necessarily know whether another
thread is waiting, so the number of unblocked threads may be zero or one.
Finally, you might want to think about what the value of the semaphore
means. If the value is positive, then it represents the number of threads that
can decrement without blocking. If it is negative, then it represents the number
of threads that have blocked and are waiting. If the value is zero, it means there
are no threads waiting, but if a thread tries to decrement, it will block.
2.2 Syntax
In most programming environments, an implementation of semaphores is avail-
able as part of the programming language or the operating system. Diﬀerent
implementations sometimes oﬀer slightly diﬀerent capabilities, and usually re-
quire diﬀerent syntax.
In this book I will use a simple pseudo-language to demonstrate how
semaphores work. The syntax for creating a new semaphore and initializing
it is
Listing 2.1: Semaphore initialization syntax
1 fred = Semaphore(1)
The function Semaphore is a constructor; it creates and returns a new
Semaphore. The initial value of the semaphore is passed as a parameter to
the constructor.
The semaphore operations go by diﬀerent names in diﬀerent environments.
The most common alternatives are
Listing 2.2: Semaphore operations
1 fred.increment()
2 fred.decrement()
and
Listing 2.3: Semaphore operations
1 fred.signal()
2 fred.wait()
and

21.
2.3 Why semaphores? 9
Listing 2.4: Semaphore operations
1 fred.V()
2 fred.P()
It may be surprising that there are so many names, but there is a reason for the
plurality. increment and decrement describe what the operations do. signal
and wait describe what they are often used for. And V and P were the original
names proposed by Dijkstra, who wisely realized that a meaningless name is
better than a misleading name1 .
I consider the other pairs misleading because increment and decrement
neglect to mention the possibility of blocking and waking, and semaphores are
often used in ways that have nothing to do with signal and wait.
If you insist on meaningful names, then I would suggest these:
Listing 2.5: Semaphore operations
1 fred.increment_and_wake_a_waiting_process_if_any()
2 fred.decrement_and_block_if_the_result_is_negative()
I don’t think the world is likely to embrace either of these names soon. In
the meantime, I choose (more or less arbitrarily) to use signal and wait.
2.3 Why semaphores?
Looking at the deﬁnition of semaphores, it is not at all obvious why they are use-
ful. It’s true that we don’t need semaphores to solve synchronization problems,
but there are some advantages to using them:
• Semaphores impose deliberate constraints that help programmers avoid
errors.
• Solutions using semaphores are often clean and organized, making it easy
to demonstrate their correctness.
• Semaphores can be implemented eﬃciently on many systems, so solutions
that use semaphores are portable and usually eﬃcient.
1 Actually, V and P aren’t completely meaningless to people who speak Dutch.

23.
Chapter 3
Basic synchronization
patterns
This chapter presents a series of basic synchronization problems and shows ways
of using semaphores to solve them. These problems include serialization and
mutual exclusion, which we have already seen, along with others.
3.1 Signaling
Possibly the simplest use for a semaphore is signaling, which means that one
thread sends a signal to another thread to indicate that something has happened.
Signaling makes it possible to guarantee that a section of code in one thread
will run before a section of code in another thread; in other words, it solves the
serialization problem.
Assume that we have a semaphore named sem with initial value 0, and that
Threads A and B have shared access to it.
Thread A Thread B
1 statement a1 1 sem.wait()
2 sem.signal() 2 statement b1
The word statement represents an arbitrary program statement. To make
the example concrete, imagine that a1 reads a line from a ﬁle, and b1 displays
the line on the screen. The semaphore in this program guarantees that Thread
A has completed a1 before Thread B begins b1.
Here’s how it works: if thread B gets to the wait statement ﬁrst, it will ﬁnd
the initial value, zero, and it will block. Then when Thread A signals, Thread
B proceeds.
Similarly, if Thread A gets to the signal ﬁrst then the value of the semaphore
will be incremented, and when Thread B gets to the wait, it will proceed im-
mediately. Either way, the order of a1 and b1 is guaranteed.

24.
12 Basic synchronization patterns
This use of semaphores is the basis of the names signal and wait, and
in this case the names are conveniently mnemonic. Unfortunately, we will see
other cases where the names are less helpful.
Speaking of meaningful names, sem isn’t one. When possible, it is a good
idea to give a semaphore a name that indicates what it represents. In this case
a name like a1Done might be good, so that a1done.signal() means “signal
that a1 is done,” and a1done.wait() means “wait until a1 is done.”
3.2 Rendezvous
Puzzle: Generalize the signal pattern so that it works both ways. Thread A has
to wait for Thread B and vice versa. In other words, given this code
Thread A Thread B
1 statement a1 1 statement b1
2 statement a2 2 statement b2
we want to guarantee that a1 happens before b2 and b1 happens before a2. In
writing your solution, be sure to specify the names and initial values of your
semaphores (little hint there).
Your solution should not enforce too many constraints. For example, we
don’t care about the order of a1 and b1. In your solution, either order should
be possible.
This synchronization problem has a name; it’s a rendezvous. The idea is
that two threads rendezvous at a point of execution, and neither is allowed to
proceed until both have arrived.

25.
3.2 Rendezvous 13
3.2.1 Rendezvous hint
The chances are good that you were able to ﬁgure out a solution, but if not,
here is a hint. Create two semaphores, named aArrived and bArrived, and
initialize them both to zero.
As the names suggest, aArrived indicates whether Thread A has arrived at
the rendezvous, and bArrived likewise.

27.
3.2 Rendezvous 15
3.2.2 Rendezvous solution
Here is my solution, based on the previous hint:
Thread A Thread B
1 statement a1 1 statement b1
2 aArrived.signal() 2 bArrived.signal()
3 bArrived.wait() 3 aArrived.wait()
4 statement a2 4 statement b2
While working on the previous problem, you might have tried something like
this:
Thread A Thread B
1 statement a1 1 statement b1
2 bArrived.wait() 2 bArrived.signal()
3 aArrived.signal() 3 aArrived.wait()
4 statement a2 4 statement b2
This solution also works, although it is probably less eﬃcient, since it might
have to switch between A and B one time more than necessary.
If A arrives ﬁrst, it waits for B. When B arrives, it wakes A and might
proceed immediately to its wait in which case it blocks, allowing A to reach its
signal, after which both threads can proceed.
Think about the other possible paths through this code and convince yourself
that in all cases neither thread can proceed until both have arrived.
3.2.3 Deadlock #1
Again, while working on the previous problem, you might have tried something
like this:
Thread A Thread B
1 statement a1 1 statement b1
2 bArrived.wait() 2 aArrived.wait()
3 aArrived.signal() 3 bArrived.signal()
4 statement a2 4 statement b2
If so, I hope you rejected it quickly, because it has a serious problem. As-
suming that A arrives ﬁrst, it will block at its wait. When B arrives, it will also
block, since A wasn’t able to signal aArrived. At this point, neither thread can
proceed, and never will.
This situation is called a deadlock and, obviously, it is not a successful
solution of the synchronization problem. In this case, the error is obvious, but
often the possibility of deadlock is more subtle. We will see more examples later.

28.
16 Basic synchronization patterns
3.3 Mutex
A second common use for semaphores is to enforce mutual exclusion. We have al-
ready seen one use for mutual exclusion, controlling concurrent access to shared
variables. The mutex guarantees that only one thread accesses the shared vari-
able at a time.
A mutex is like a token that passes from one thread to another, allowing one
thread at a time to proceed. For example, in The Lord of the Flies a group of
children use a conch as a mutex. In order to speak, you have to hold the conch.
As long as only one child holds the conch, only one can speak1 .
Similarly, in order for a thread to access a shared variable, it has to “get”
the mutex; when it is done, it “releases” the mutex. Only one thread can hold
the mutex at a time.
Puzzle: Add semaphores to the following example to enforce mutual exclu-
sion to the shared variable count.
Thread A Thread B
count = count + 1 count = count + 1
1 Although this metaphor is helpful, for now, it can also be misleading, as you will see in
Section 5.5

29.
3.3 Mutex 17
3.3.1 Mutual exclusion hint
Create a semaphore named mutex that is initialized to 1. A value of one means
that a thread may proceed and access the shared variable; a value of zero means
that it has to wait for another thread to release the mutex.

31.
3.4 Multiplex 19
3.3.2 Mutual exclusion solution
Here is a solution:
Thread A Thread B
mutex.wait() mutex.wait()
# critical section # critical section
count = count + 1 count = count + 1
mutex.signal() mutex.signal()
Since mutex is initially 1, whichever thread gets to the wait ﬁrst will be able
to proceed immediately. Of course, the act of waiting on the semaphore has the
eﬀect of decrementing it, so the second thread to arrive will have to wait until
the ﬁrst signals.
I have indented the update operation to show that it is contained within the
mutex.
In this example, both threads are running the same code. This is sometimes
called a symmetric solution. If the threads have to run diﬀerent code, the solu-
tion is asymmetric. Symmetric solutions are often easier to generalize. In this
case, the mutex solution can handle any number of concurrent threads without
modiﬁcation. As long as every thread waits before performing an update and
signals after, then no two threads will access count concurrently.
Often the code that needs to be protected is called the critical section, I
suppose because it is critically important to prevent concurrent access.
In the tradition of computer science and mixed metaphors, there are several
other ways people sometimes talk about mutexes. In the metaphor we have been
using so far, the mutex is a token that is passed from one thread to another.
In an alternative metaphor, we think of the critical section as a room, and
only one thread is allowed to be in the room at a time. In this metaphor,
mutexes are called locks, and a thread is said to lock the mutex before entering
and unlock it while exiting. Occasionally, though, people mix the metaphors
and talk about “getting” or “releasing” a lock, which doesn’t make much sense.
Both metaphors are potentially useful and potentially misleading. As you
work on the next problem, try out both ways of thinking and see which one
leads you to a solution.
3.4 Multiplex
Puzzle: Generalize the previous solution so that it allows multiple threads to
run in the critical section at the same time, but it enforces an upper limit on
the number of concurrent threads. In other words, no more than n threads can
run in the critical section at the same time.
This pattern is called a multiplex. In real life, the multiplex problem occurs
at busy nightclubs where there is a maximum number of people allowed in the
building at a time, either to maintain ﬁre safety or to create the illusion of
exclusivity.

32.
20 Basic synchronization patterns
At such places a bouncer usually enforces the synchronization constraint by
keeping track of the number of people inside and barring arrivals when the room
is at capacity. Then, whenever one person leaves another is allowed to enter.
Enforcing this constraint with semaphores may sound diﬃcult, but it is
almost trivial.

33.
3.5 Barrier 21
3.4.1 Multiplex solution
To allow multiple threads to run in the critical section, just initialize the
semaphore to n, which is the maximum number of threads that should be al-
lowed.
At any time, the value of the semaphore represents the number of additional
threads that may enter. If the value is zero, then the next thread will block
until one of the threads inside exits and signals. When all threads have exited
the value of the semaphore is restored to n.
Since the solution is symmetric, it’s conventional to show only one copy of the
code, but you should imagine multiple copies of the code running concurrently
in multiple threads.
Listing 3.1: Multiplex solution
1 multiplex.wait()
2 critical section
3 multiplex.signal()
What happens if the critical section is occupied and more than one thread
arrives? Of course, what we want is for all the arrivals to wait. This solution
does exactly that. Each time an arrival joins the queue, the semaphore is decre-
mented, so that the value of the semaphore (negated) represents the number of
threads in queue.
When a thread leaves, it signals the semaphore, incrementing its value and
allowing one of the waiting threads to proceed.
Thinking again of metaphors, in this case I ﬁnd it useful to think of the
semaphore as a set of tokens (rather than a lock). As each thread invokes wait,
it picks up one of the tokens; when it invokes signal it releases one. Only a
thread that holds a token can enter the room. If no tokens are available when
a thread arrives, it waits until another thread releases one.
In real life, ticket windows sometimes use a system like this. They hand
out tokens (sometimes poker chips) to customers in line. Each token allows the
holder to buy a ticket.
3.5 Barrier
Consider again the Rendezvous problem from Section 3.2. A limitation of the
solution we presented is that it does not work with more than two threads.
Puzzle: Generalize the rendezvous solution. Every thread should run the
following code:
Listing 3.2: Barrier code
1 rendezvous
2 critical point

34.
22 Basic synchronization patterns
The synchronization requirement is that no thread executes critical point
until after all threads have executed rendezvous.
You can assume that there are n threads and that this value is stored in a
variable, n, that is accessible from all threads.
When the ﬁrst n − 1 threads arrive they should block until the nth thread
arrives, at which point all the threads may proceed.

35.
3.5 Barrier 23
3.5.1 Barrier hint
For many of the problems in this book I will provide hints by presenting the
variables I used in my solution and explaining their roles.
Listing 3.3: Barrier hint
1 n = the number of threads
2 count = 0
3 mutex = Semaphore(1)
4 barrier = Semaphore(0)
count keeps track of how many threads have arrived. mutex provides exclu-
sive access to count so that threads can increment it safely.
barrier is locked (zero or negative) until all threads arrive; then it should
be unlocked (1 or more).

37.
3.5 Barrier 25
3.5.2 Barrier non-solution
First I will present a solution that is not quite right, because it is useful to
examine incorrect solutions and ﬁgure out what is wrong.
Listing 3.4: Barrier non-solution
1 rendezvous
2
3 mutex.wait()
4 count = count + 1
5 mutex.signal()
6
7 if count == n: barrier.signal()
8
9 barrier.wait()
10
11 critical point
Since count is protected by a mutex, it counts the number of threads that
pass. The ﬁrst n − 1 threads wait when they get to the barrier, which is initially
locked. When the nth thread arrives, it unlocks the barrier.
Puzzle: What is wrong with this solution?

39.
3.5 Barrier 27
3.5.3 Deadlock #2
The problem is a deadlock.
An an example, imagine that n = 5 and that 4 threads are waiting at the
barrier. The value of the semaphore is the number of threads in queue, negated,
which is -4.
When the 5th thread signals the barrier, one of the waiting threads is allowed
to proceed, and the semaphore is incremented to -3.
But then no one signals the semaphore again and none of the other threads
can pass the barrier. This is a second example of a deadlock.
Puzzle: Does this code always create a deadlock? Can you ﬁnd an execution
path through this code that does not cause a deadlock?
Puzzle: Fix the problem.

41.
3.5 Barrier 29
3.5.4 Barrier solution
Finally, here is a working barrier:
Listing 3.5: Barrier solution
1 rendezvous
2
3 mutex.wait()
4 count = count + 1
5 mutex.signal()
6
7 if count == n: barrier.signal()
8
9 barrier.wait()
10 barrier.signal()
11
12 critical point
The only change is another signal after waiting at the barrier. Now as each
thread passes, it signals the semaphore so that the next thread can pass.
This pattern, a wait and a signal in rapid succession, occurs often enough
that it has a name; it’s called a turnstile, because it allows one thread to pass
at a time, and it can be locked to bar all threads.
In its initial state (zero), the turnstile is locked. The nth thread unlocks it
and then all n threads go through.
It might seem dangerous to read the value of count outside the mutex. In
this case it is not a problem, but in general it is probably not a good idea.
We will clean this up in a few pages, but in the meantime, you might want to
consider these questions: After the nth thread, what state is the turnstile in?
Is there any way the barrier might be signaled more than once?

43.
3.6 Reusable barrier 31
3.5.5 Deadlock #3
Since only one thread at a time can pass through the mutex, and only one
thread at a time can pass through the turnstile, it might seen reasonable to put
the turnstile inside the mutex, like this:
Listing 3.6: Bad barrier solution
1 rendezvous
2
3 mutex.wait()
4 count = count + 1
5 if count == n: barrier.signal()
6
7 barrier.wait()
8 barrier.signal()
9 mutex.signal()
10
11 critical point
This turns out to be a bad idea because it can cause a deadlock.
Imagine that the ﬁrst thread enters the mutex and then blocks when it
reaches the turnstile. Since the mutex is locked, no other threads can enter,
so the condition, count==n, will never be true and no one will ever unlock the
turnstile.
In this case the deadlock is fairly obvious, but it demonstrates a common
source of deadlocks: blocking on a semaphore while holding a mutex.
3.6 Reusable barrier
Often a set of cooperating threads will perform a series of steps in a loop and
synchronize at a barrier after each step. For this application we need a reusable
barrier that locks itself after all the threads have passed through.
Puzzle: Rewrite the barrier solution so that after all the threads have passed
through, the turnstile is locked again.

47.
3.6 Reusable barrier 35
3.6.2 Reusable barrier problem #1
There is a problem spot at Line 7 of the previous code.
If the n − 1th thread is interrupted at this point, and then the nth thread
comes through the mutex, both threads will ﬁnd that count==n and both
threads will signal the turnstile. In fact, it is even possible that all the threads
will signal the turnstile.
Similarly, at Line 18 it is possible for multiple threads to wait, which will
cause a deadlock.
Puzzle: Fix the problem.

51.
3.6 Reusable barrier 39
3.6.4 Reusable barrier hint
As it is currently written, this code allows a precocious thread to pass through
the second mutex, then loop around and pass through the ﬁrst mutex and the
turnstile, eﬀectively getting ahead of the other threads by a lap.
To solve this problem we can use two turnstiles.
Listing 3.9: Reusable barrier hint
1 turnstile = Semaphore(0)
2 turnstile2 = Semaphore(1)
3 mutex = Semaphore(1)
Initially the ﬁrst is locked and the second is open. When all the threads
arrive at the ﬁrst, we lock the second and unlock the ﬁrst. When all the threads
arrive at the second we relock the ﬁrst, which makes it safe for the threads to
loop around to the beginning, and then open the second.

53.
3.6 Reusable barrier 41
3.6.5 Reusable barrier solution
Listing 3.10: Reusable barrier solution
1 # rendezvous
2
3 mutex.wait()
4 count += 1
5 if count == n:
6 turnstile2.wait() # lock the second
7 turnstile.signal() # unlock the first
8 mutex.signal()
9
10 turnstile.wait() # first turnstile
11 turnstile.signal()
12
13 # critical point
14
15 mutex.wait()
16 count -= 1
17 if count == 0:
18 turnstile.wait() # lock the first
19 turnstile2.signal() # unlock the second
20 mutex.signal()
21
22 turnstile2.wait() # second turnstile
23 turnstile2.signal()
This solution is sometimes called a two-phase barrier because it forces all
the threads to wait twice: once for all the threads to arrive and again for all the
threads to execute the critical section.
Unfortunately, this solution is typical of most non-trivial synchronization
code: it is diﬃcult to be sure that a solution is correct. Often there is a subtle
way that a particular path through the program can cause an error.
To make matters worse, testing an implementation of a solution is not much
help. The error might occur very rarely because the particular path that causes
it might require a spectacularly unlucky combination of circumstances. Such
errors are almost impossible to reproduce and debug by conventional means.
The only alternative is to examine the code carefully and “prove” that it is
correct. I put “prove” in quotation marks because I don’t mean, necessarily,
that you have to write a formal proof (although there are zealots who encourage
such lunacy).
The kind of proof I have in mind is more informal. We can take advantage
of the structure of the code, and the idioms we have developed, to assert, and
then demonstrate, a number of intermediate-level claims about the program.
For example:

54.
42 Basic synchronization patterns
1. Only the nth thread can lock or unlock the turnstiles.
2. Before a thread can unlock the ﬁrst turnstile, it has to close the second,
and vice versa; therefore it is impossible for one thread to get ahead of
the others by more than one turnstile.
By ﬁnding the right kinds of statements to assert and prove, you can some-
times ﬁnd a concise way to convince yourself (or a skeptical colleague) that your
code is bulletproof.

55.
3.6 Reusable barrier 43
3.6.6 Preloaded turnstile
One nice thing about a turnstile is that it is a versatile component you can
use in a variety of solutions. But one drawback is that it forces threads to go
through sequentially, which may cause more context switching than necessary.
In the reusable barrier solution, we can simplify the solution if the thread
that unlocks the turnstile preloads the turnstile with enough signals to let the
right number of threads through2 .
The syntax I am using here assumes that signal can take a parameter
that speciﬁes the number of signals. This is a non-standard feature, but it
would be easy to implement with a loop. The only thing to keep in mind is
that the multiple signals are not atomic; that is, the signaling thread might be
interrupted in the loop. But in this case that is not a problem.
Listing 3.11: Reusable barrier solution
1 # rendezvous
2
3 mutex.wait()
4 count += 1
5 if count == n:
6 turnstile.signal(n) # unlock the first
7 mutex.signal()
8
9 turnstile.wait() # first turnstile
10
11 # critical point
12
13 mutex.wait()
14 count -= 1
15 if count == 0:
16 turnstile2.signal(n) # unlock the second
17 mutex.signal()
18
19 turnstile2.wait() # second turnstile
When the nth thread arrives, it preloads the ﬁrst turnstile with one signal
for each thread. When the nth thread passes the turnstile, it “takes the last
token” and leaves the turnstile locked again.
The same thing happens at the second turnstile, which is unlocked when the
last thread goes through the mutex.
2 Thanks to Matt Tesch for this solution!

57.
3.7 Queue 45
Optionally, code that uses a barrier can call phase1 and phase2 separately,
if there is something else that should be done in between.
3.7 Queue
Semaphores can also be used to represent a queue. In this case, the initial value
is 0, and usually the code is written so that it is not possible to signal unless
there is a thread waiting, so the value of the semaphore is never positive.
For example, imagine that threads represent ballroom dancers and that two
kinds of dancers, leaders and followers, wait in two queues before entering the
dance ﬂoor. When a leader arrives, it checks to see if there is a follower waiting.
If so, they can both proceed. Otherwise it waits.
Similarly, when a follower arrives, it checks for a leader and either proceeds
or waits, accordingly.
Puzzle: write code for leaders and followers that enforces these constraints.

61.
3.7 Queue 49
3.7.2 Queue solution
Here is the code for leaders:
Listing 3.15: Queue solution (leaders)
1 followerQueue.signal()
2 leaderQueue.wait()
3 dance()
And here is the code for followers:
Listing 3.16: Queue solution (followers)
1 leaderQueue.signal()
2 followerQueue.wait()
3 dance()
This solution is about as simple as it gets; it is just a Rendezvous. Each
leader signals exactly one follower, and each follower signals one leader, so it
is guaranteed that leaders and followers are allowed to proceed in pairs. But
whether they actually proceed in pairs is not clear. It is possible for any number
of threads to accumulate before executing dance, and so it is possible for any
number of leaders to dance before any followers do. Depending on the semantics
of dance, that behavior may or may not be problematic.
To make things more interesting, let’s add the additional constraint that each
leader can invoke dance concurrently with only one follower, and vice versa. In
other words, you got to dance with the one that brought you3 .
Puzzle: write a solution to this “exclusive queue” problem.
3 Song lyric performed by Shania Twain

65.
3.7 Queue 53
3.7.4 Exclusive queue solution
Here is the code for leaders:
Listing 3.18: Queue solution (leaders)
1 mutex.wait()
2 if followers > 0:
3 followers--
4 followerQueue.signal()
5 else:
6 leaders++
7 mutex.signal()
8 leaderQueue.wait()
9
10 dance()
11 rendezvous.wait()
12 mutex.signal()
When a leader arrives, it gets the mutex that protects leaders and
followers. If there is a follower waiting, the leader decrements followers,
signals a follower, and then invokes dance, all before releasing mutex. That
guarantees that there can be only one follower thread running dance concur-
rently.
If there are no followers waiting, the leader has to give up the mutex before
waiting on leaderQueue.
The code for followers is similar:
Listing 3.19: Queue solution (followers)
1 mutex.wait()
2 if leaders > 0:
3 leaders--
4 leaderQueue.signal()
5 else:
6 followers++
7 mutex.signal()
8 followerQueue.wait()
9
10 dance()
11 rendezvous.signal()
When a follower arrives, it checks for a waiting leader. If there is one, the
follower decrements leaders, signals a leader, and executes dance, all without
releasing mutex. Actually, in this case the follower never releases mutex; the
leader does. We don’t have to keep track of which thread has the mutex because
we know that one of them does, and either one of them can release it. In my
solution it’s always the leader.

66.
54 Basic synchronization patterns
When a semaphore is used as a queue4 , I ﬁnd it useful to read “wait” as
“wait for this queue” and signal as “let someone from this queue go.”
In this code we never signal a queue unless someone is waiting, so the values
of the queue semaphores are seldom positive. It is possible, though. See if you
can ﬁgure out how.
4 A semaphore used as a queue is very similar to a condition variable. The primary diﬀerence
is that threads have to release the mutex explicitly before waiting, and reacquire it explicitly
afterwards (but only if they need it).

67.
3.8 Fifo queue 55
3.8 Fifo queue
If there is more than one thread waiting in queue when a semaphore is signaled,
there is usually no way to tell which thread will be woken. Some implementa-
tions wake threads up in a particular order, like ﬁrst-in-ﬁrst-out, but the seman-
tics of semaphores don’t require any particular order. Even if your environment
doesn’t provide ﬁrst-in-ﬁrst-out queueing, you can build it yourself.
Puzzle: use semaphores to build a ﬁrst-in-ﬁrst-out queue. Each time the Fifo
is signaled, the thread at the head of the queue should proceed. If more than
one thread is waiting on a semaphore, you should not make any assumptions
about which thread will proceed when the semaphore is signaled.
For bonus points, your solution should deﬁne a class named Fifo that pro-
vides methods named wait and signal.

69.
3.8 Fifo queue 57
3.8.1 Fifo queue hint
A natural solution is to allocate one semaphore to each thread by having each
thread run the following initialization:
Listing 3.20: Thread initialization
1 local mySem = Semaphore(0)
As each thread enters the Fifo, it adds its semaphore to a Queue data struc-
ture. When a thread signals the queue, it removes the semaphore at the head
of the Queue and signals it.
Using Python syntax, here is what the Fifo class deﬁnition might look like:
Listing 3.21: Fifo class deﬁnition
1 class Fifo:
2 def __init__(self):
3 self.queue = Queue()
4 self.mutex = Semaphore(1)
You can assume that there is a data structure named Queue that provides
methods named add and remove, but you should not assume that the Queue is
thread-safe; in other words, you have to enforce exclusive access to the Queue.

73.
Chapter 4
Classical synchronization
problems
In this chapter we examine the classical problems that appear in nearly every
operating systems textbook. They are usually presented in terms of real-world
problems, so that the statement of the problem is clear and so that students
can bring their intuition to bear.
For the most part, though, these problems do not happen in the real world, or
if they do, the real-world solutions are not much like the kind of synchronization
code we are working with.
The reason we are interested in these problems is that they are analogous
to common problems that operating systems (and some applications) need to
solve. For each classical problem I will present the classical formulation, and
also explain the analogy to the corresponding OS problem.
4.1 Producer-consumer problem
In multithreaded programs there is often a division of labor between threads. In
one common pattern, some threads are producers and some are consumers. Pro-
ducers create items of some kind and add them to a data structure; consumers
remove the items and process them.
Event-driven programs are a good example. An “event” is something that
happens that requires the program to respond: the user presses a key or moves
the mouse, a block of data arrives from the disk, a packet arrives from the
network, a pending operation completes.
Whenever an event occurs, a producer thread creates an event object and
adds it to the event buﬀer. Concurrently, consumer threads take events out
of the buﬀer and process them. In this case, the consumers are called “event
handlers.”
There are several synchronization constraints that we need to enforce to
make this system work correctly:

74.
62 Classical synchronization problems
• While an item is being added to or removed from the buﬀer, the buﬀer is
in an inconsistent state. Therefore, threads must have exclusive access to
the buﬀer.
• If a consumer thread arrives while the buﬀer is empty, it blocks until a
producer adds a new item.
Assume that producers perform the following operations over and over:
Listing 4.1: Basic producer code
1 event = waitForEvent()
2 buffer.add(event)
Also, assume that consumers perform the following operations:
Listing 4.2: Basic consumer code
1 event = buffer.get()
2 event.process()
As speciﬁed above, access to the buﬀer has to be exclusive, but
waitForEvent and event.process can run concurrently.
Puzzle: Add synchronization statements to the producer and consumer code
to enforce the synchronization constraints.

75.
4.1 Producer-consumer problem 63
4.1.1 Producer-consumer hint
Here are the variables you might want to use:
Listing 4.3: Producer-consumer initialization
1 mutex = Semaphore(1)
2 items = Semaphore(0)
3 local event
Not surprisingly, mutex provides exclusive access to the buﬀer. When items
is positive, it indicates the number of items in the buﬀer. When it is negative,
it indicates the number of consumer threads in queue.
event is a local variable, which in this context means that each thread has
its own version. So far we have been assuming that all threads have access to
all variables, but we will sometimes ﬁnd it useful to attach a variable to each
thread.
There are a number of ways this can be implemented in diﬀerent environ-
ments:
• If each thread has its own run-time stack, then any variables allocated on
the stack are thread-speciﬁc.
• If threads are represented as objects, we can add an attribute to each
thread object.
• If threads have unique IDs, we can use the IDs as an index into an array
or hash table, and store per-thread data there.
In most programs, most variables are local unless declared otherwise, but in
this book most variables are shared, so we will assume that that variables are
shared unless they are explicitly declared local.

77.
4.1 Producer-consumer problem 65
4.1.2 Producer-consumer solution
Here is the producer code from my solution.
Listing 4.4: Producer solution
1 event = waitForEvent()
2 mutex.wait()
3 buffer.add(event)
4 items.signal()
5 mutex.signal()
The producer doesn’t have to get exclusive access to the buﬀer until it gets
an event. Several threads can run waitForEvent concurrently.
The items semaphore keeps track of the number of items in the buﬀer. Each
time the producer adds an item, it signals items, incrementing it by one.
The consumer code is similar.
Listing 4.5: Consumer solution
1 items.wait()
2 mutex.wait()
3 event = buffer.get()
4 mutex.signal()
5 event.process()
Again, the buﬀer operation is protected by a mutex, but before the consumer
gets to it, it has to decrement items. If items is zero or negative, the consumer
blocks until a producer signals.
Although this solution is correct, there is an opportunity to make one small
improvement to its performance. Imagine that there is at least one consumer
in queue when a producer signals items. If the scheduler allows the consumer
to run, what happens next? It immediately blocks on the mutex that is (still)
held by the producer.
Blocking and waking up are moderately expensive operations; performing
them unnecessarily can impair the performance of a program. So it would
probably be better to rearrange the producer like this:
Listing 4.6: Improved producer solution
1 event = waitForEvent()
2 mutex.wait()
3 buffer.add(event)
4 mutex.signal()
5 items.signal()
Now we don’t bother unblocking a consumer until we know it can proceed
(except in the rare case that another producer beats it to the mutex).
There’s one other thing about this solution that might bother a stickler. In
the hint section I claimed that the items semaphore keeps track of the number

78.
66 Classical synchronization problems
of items in queue. But looking at the consumer code, we see the possibility that
several consumers could decrement items before any of them gets the mutex
and removes an item from the buﬀer. At least for a little while, items would
be inaccurate.
We might try to address that by checking the buﬀer inside the mutex:
Listing 4.7: Broken consumer solution
1 mutex.wait()
2 items.wait()
3 event = buffer.get()
4 mutex.signal()
5 event.process()
This is a bad idea.
Puzzle: why?

79.
4.1 Producer-consumer problem 67
4.1.3 Deadlock #4
If the consumer is running this code
Listing 4.8: Broken consumer solution
1 mutex.wait()
2 items.wait()
3 event = buffer.get()
4 mutex.signal()
5
6 event.process()
it can cause a deadlock. Imagine that the buﬀer is empty. A consumer arrives,
gets the mutex, and then blocks on items. When the producer arrives, it blocks
on mutex and the system comes to a grinding halt.
This is a common error in synchronization code: any time you wait for a
semaphore while holding a mutex, there is a danger of deadlock. When you are
checking a solution to a synchronization problem, you should check for this kind
of deadlock.
4.1.4 Producer-consumer with a ﬁnite buﬀer
In the example I described above, event-handling threads, the shared buﬀer is
usually inﬁnite (more accurately, it is bounded by system resources like physical
memory and swap space).
In the kernel of the operating system, though, there are limits on available
space. Buﬀers for things like disk requests and network packets are usually ﬁxed
size. In situations like these, we have an additional synchronization constraint:
• If a producer arrives when the buﬀer is full, it blocks until a consumer
removes an item.
Assume that we know the size of the buﬀer. Call it bufferSize. Since we
have a semaphore that is keeping track of the number of items, it is tempting
to write something like
Listing 4.9: Broken ﬁnite buﬀer solution
1 if items >= bufferSize:
2 block()
But we can’t. Remember that we can’t check the current value of a
semaphore; the only operations are wait and signal.
Puzzle: write producer-consumer code that handles the ﬁnite-buﬀer con-
straint.

81.
4.1 Producer-consumer problem 69
4.1.5 Finite buﬀer producer-consumer hint
Add a second semaphore to keep track of the number of available spaces in the
buﬀer.
Listing 4.10: Finite-buﬀer producer-consumer initialization
1 mutex = Semaphore(1)
2 items = Semaphore(0)
3 spaces = Semaphore(buffer.size())
When a consumer removes an item it should signal spaces. When a producer
arrives it should decrement spaces, at which point it might block until the next
consumer signals.

83.
4.2 Readers-writers problem 71
4.1.6 Finite buﬀer producer-consumer solution
Here is a solution.
Listing 4.11: Finite buﬀer consumer solution
1 items.wait()
2 mutex.wait()
3 event = buffer.get()
4 mutex.signal()
5 spaces.signal()
6
7 event.process()
The producer code is symmetric, in a way:
Listing 4.12: Finite buﬀer producer solution
1 event = waitForEvent()
2
3 spaces.wait()
4 mutex.wait()
5 buffer.add(event)
6 mutex.signal()
7 items.signal()
In order to avoid deadlock, producers and consumers check availability be-
fore getting the mutex. For best performance, they release the mutex before
signaling.
4.2 Readers-writers problem
The next classical problem, called the Reader-Writer Problem, pertains to any
situation where a data structure, database, or ﬁle system is read and modiﬁed
by concurrent threads. While the data structure is being written or modiﬁed
it is often necessary to bar other threads from reading, in order to prevent a
reader from interrupting a modiﬁcation in progress and reading inconsistent or
invalid data.
As in the producer-consumer problem, the solution is asymmetric. Readers
and writers execute diﬀerent code before entering the critical section. The
synchronization constraints are:
1. Any number of readers can be in the critical section simultaneously.
2. Writers must have exclusive access to the critical section.
In other words, a writer cannot enter the critical section while any other
thread (reader or writer) is there, and while the writer is there, no other thread
may enter.

84.
72 Classical synchronization problems
The exclusion pattern here might be called categorical mutual exclusion.
A thread in the critical section does not necessarily exclude other threads, but
the presence of one category in the critical section excludes other categories.
Puzzle: Use semaphores to enforce these constraints, while allowing readers
and writers to access the data structure, and avoiding the possibility of deadlock.

85.
4.2 Readers-writers problem 73
4.2.1 Readers-writers hint
Here is a set of variables that is suﬃcient to solve the problem.
Listing 4.13: Readers-writers initialization
1 int readers = 0
2 mutex = Semaphore(1)
3 roomEmpty = Semaphore(1)
The counter readers keeps track of how many readers are in the room.
mutex protects the shared counter.
roomEmpty is 1 if there are no threads (readers or writers) in the critical
section, and 0 otherwise. This demonstrates the naming convention I use for
semaphores that indicate a condition. In this convention, “wait” usually means
“wait for the condition to be true” and “signal” means “signal that the condition
is true”.