Operating R.S. Gaines
Systems Editor
Concurrent Reading
and Writing
Leslie Lamport
Massachusetts Computer Associates
The problem of sharing data among asynchronous
processes is considered. It is assumed that only one
process at a time can modify the data, but concurrent
reading and writing is permitted. Two general theorems
are proved, and some algorithms are presented to
illustrate their use. These include a solution to the
general problem in which a read is repeated if it might
have obtained an incorrect result, and two techniques
for transmitting messages between processes. These
solutions do not assume any synchronizing mechanism
other than data which can be written by one process
and read by other processes.
Key Words and Phrases: asynchronous multipro-
cessing, multiprocess synchronization, readers/writers
problem, shared data
CR Categories: 4.32, 5.24
Copyright © 1977, Association for Computing Machinery, Inc.
General permission to republish, but not for profit, all or part of
this material is granted provided that ACM's copyright notice is
given and that reference is made to the publication, to its date of
issue, and to the fact that reprinting privileges were granted by
permission of the Association for Computing Machinery.
This research was supported by the Advanced Research Projects
Agency of the Department of Defense and was monitored by the
Range Measurements Laboratory under contract number FO8606-
74-0068.
Author's address: Massachusetts Computer Associates, Inc., 26
Princess Street, Wakefield, MA 01880.
806
Introduction
We consider the problem of the concurrent reading
and writing of a common data item by separate proc-
esses: the
readers~writers problem.
We assume that the
hardware solves the problem for an atomic unit of
data. However, the data item may be composed of
several atomic units. For example, suppose the atomic
unit of data is a decimal digit and the data item is a
three-digit number. If one process is reading the num-
ber while another process is changing it from 99 to
100, then the read could obtain the value 199-
whereas it presumably wants to obtain either 99 or
100. In practice, the atomic unit of data might be an
individual memory byte or a single disk track.
Previous solutions [1, 3] have involved mutual
exclusions: all other processes are denied access to the
data item while one process is modifying it. They seem
to have been motivated by the case of a fairly large
data file. Like most multiprocess algorithms, they
assumed an a pr{ori solution to the problem of concur-
rent access to the program variables (or semaphores)-
presumably implemented by the hardware and/or
opening system.
We are motivated by systems in which the processes
may be running on separate computers. True concur-
rent execution is then possible, and achieving mutual
exclusion may require considerable overhead. In addi-
tion to the question of overhead, there are two reasons
for studying algorithms which do not involve mutual
exclusions: (1) Mutual exclusion requires that a writer
wait until all current read operations are completed.
This may be undesirable if the writer has higher priority
than the readers. (2) The concurrent reading and
writing may be needed to implement mutual exclusion.
We therefore consider the problem of concurrent
reading and writing without introducing mutual exclu-
sion. We will assume that there are certain basic units
of data, called
digits,
whose reading and writing are
indivisible, atomic operations; i.e. we assume that the
hardware automatically sequences concurrent opera-
tions to a single digit. However, a digit might contain
just a single bit of data. A future paper will consider
the case in which truly concurrent reading and writing
is possible even at the level of the individual digit.
We only consider the case in which no two proc-
esses may try to write the same data concurrently.
Mutual exclusion of writers seems unavoidable, and
some other algorithm (such as the one in [5]) must be
used to enforce this mutual exclusion if several proc-
esses can modify the same data.
We prove two general theorems, and then describe
several sample applications. These include a simple
Communications November 1977
of Volume 20
the ACM Number 11
solution to the general readers/writer problem in which
a read is repeated if it might have obtained an incorrect
result, and two algorithms for sending messages from
one process to another.
General Theorems
Let v denote a data item composed of one or more
digits. We assume that two different processes cannot
concurrently modify v. Let v t°~ denote the initial value
of v, and let v m, v t21, . . . denote the successive values
assumed by v; i.e. each operation which writes v begins
with v equal to v u~, for some i >- 0, and ends with v
equal to v t~+a~. For convenience, we assume that v t°~ is
written by some initial operation which precedes all
read operations.
We write v = v~ ... Vm to denote that the data
item v is composed of the data items vj, and that each
vj is only written as part of a write of v. ~ For conveni-
ence, we assume that a read (write) operation of v
involves reading (writing) each vj. This implies that v ul
= v~ i~ . . . vtd, 1 for all i -> 0. If a particular read (write)
operation to v does not require reading (writing) vj,
then we will just pretend that a read (write) of vi is
performed; e.g. if the write of v t° does not involve
writing vj, then we simply pretend that a write of vj
was performed which left its value unchanged.
If a data item v is not a single digit, then reading
and writing v may involve several separate operations.
A read of v which is performed concurrently with one
or more writes to v may obtain a value different from
any of the versions v t~. The value obtained may contain
"traces" of several different versions. If a read obtains
traces of versions v t~,j, . . . , v u~l, then we say that it
obtained a value of v tk,° where k =
minimum (ia, . . . ,
ira)
and l =
maximum(il,... , im),
so 0 <- k -< I. Ifk =
l, then v tk,o = v tkj and the read obtained a consistent
version of v.
As an example, suppose v = d~ . . . d~, where the
dj are digits. Since reading and writing a single digit
are assumed to be atomic operations, a read of v
obtains a value dt~ ,1 . . . d~ j . The value d~ j is part of
the version vt*~ ~ of v, so the read obtained a trace of
that version. Hence the read obtained a value v tk,0
where k =
minimum(ia,...,
ira)
and l =
maxi-
mum(il .... , im).
If k = l, then the read obtained the
consistent version d~ kl ... d~ 1 = v tk~. Note that it is
possible for the read to obtain a consistent version
even if k :f l. For example, if d~ 5~ = d t6j , then a read
could obtain the value V 5"el = d~ 5] d~ 01 . . .dtm el = vt°l~
For a more complicated data item v, such as a list
structure with variable pointers, different versions of v
may consist of different sets of digits. A read operation
1 We use boldface type to denote a data item such as v| which
can be concurrently read and written. With this convention, the
same number may be denoted by both ordinary and boldface type-
e.g. the number j in the expression vi~.
performed while v is being written could read digits
which were never even part of v. It is not obvious how
to define what it means in general for a read to obtain
traces of version v t~. However, to solve the readers/
writer problem for v, it suffices to insure that a read
does not obtain traces of two different versions of v.
We therefore need only a necessary condition for a
read to obtain traces of version v m. We will use the
following.
If a read of v obtains traces of version v u~, then:
(i) The beginning of the read preceded the end of the
write of v u+11.
(ii) The end of the read followed the beginning of the
write of v "l.
It is easy to show that this condition is satisfied in the
case v = tl~ ... d~ considered above. The reader
should convince himself that it is a reasonable assump-
tion in general. (In fact, by properly defining "pre-
ceded" and "followed," this condition could be used
to define what it means for v to obtain traces of
version vm.)
Combining this condition with our definition of
v tk'o yields the following.
Premise.
If a read of v obtained the value
v tk,tj,
then:
(i) The beginning of the read preceded the end of the
write of v tk+~j.
(ii) The end of the read followed the beginning of the
write of v uj.
This premise can be proved when v = d~ ... d= for
digits dj. It will be taken as an axiom for other types of
data. Our results will be based upon this premise and
the assumption that a value v tk,o is a correct version of
vifk = l.
Let v = Vl . • . Vm, where the vj need not be digits.
We say that a read (write) of v is performed
from left
to right
if for each j, the read (write) of vj is completed
before the read (write) of vj+l is begun. Reading or
writing from right to left is defined in the analogous
way. Note that we have said nothing about the order
in which the digits of any single vj are read or written.
We now prove our first theorem.
THEOREM 1.
Let v = v~ . . . Vm, and assume that v
is always written from right to left. A read performed
from left to right obtains a value Vtl kl'h~ . .
. vim km'lm]
with
kl <- 11 <- k2 <- • • • <- kra
<-- lm.
PROOF. Since kj -< It, we need only show that It -
kj+l if 1 <_ j < m. We first show that the following five
events must occur in the indicated order:
(1) end writing vJ~
(2) begin writing v~ tjj
(3) end reading v~ kj,l~j
(4) begin reading vJk+Jl~,zJ +~J
(5) end writing
V~/J~ 1-[-1] •
The order in which items are written implies that
(1) precedes (2). Premise (ii) implies that (2) precedes
(3). The order in which items are read implies that (3)
precedes (4). Premise (i) implies that (4) precedes (5).
807
Communications November 1977
of Volume 20
the ACM Number 11
We have thus proved that (1) precedes (5). By the
definition of the versions v~l, this implies that ls <
ks+ 1 + 1. []
Let v =dl ... dm for digits dj. If the dj are
integers, then we call v an
m-digit number.
We define
ft(v) to be the (m - 1)-digit number dl ... din-1
composed of the leftmost m - 1 digits of v. If m = 1,
then we define /z(v) to equal zero. The usual relation
< on m-digit numbers is defined inductively by v < w
= e~... em if and only if either (i)/z(v) </z(w) or (ii)
ft(v) = ft(w) and dm< era. For example, we can
represent a time and date by a five-digit number,
where (-48) (2) (7) (14) (39) represents 14:39 o'clock
on February 7, 48 B.C. The relation < then means
earlier than.
In order to prove our second theorem, we need the
following result.
LEMMA.
Let v = dl. . . dm be an m-digit number,
and assume that i <- j implies v Ill <_ v u].
(a)
If kl <- . . . <- km <- k then d~ ~1] . . . d~ "1 <-- v tk].
(b)
Ilk1 >- . . . >- km >- k then
d~ kll . . .
d~ ~1 ~ v [kl.
PROOF. (a) The proof is by induction on m. If m =
1 then the result is trivial. Assume that m > 1 and the
result holds for m - 1. Since v[i] _< v ul implies that
/x(v tiJ) --- /z(vUl), we can apply the induction hypothesis
to conclude that d~k~l.., d~f~J _< /z(v t~) =
d~ kin1 . . . d~_~]. This implies that d~ k~J . . . d~ m] _< v tk~l .
The result then follows from the hypothesis that
km <-
k implies
v tkmj <_
v tkl.
(b) The proof of (b) is obtained from that of (a)
by reversing the inequalities. []
THEOREM 2.
Let v be an m-digit number and as-
sume that i <- j implies v t~l <_ v ul.
(a)
If v is always written from right to left, then a read
from left to right obtains a value v tk,tl <-
v it1.
(b)
If v is always written from left to right, then a read
from right to left obtains a value v tk,II >_ v t~l.
PROOF. (a) Let v = dl ... dm. Since reading and
writing a single digit are atomic operations, reading
the digit dj can give the value d~kJ.tJ j only if
k s = Is.
Theorem 1 then implies that the value v tk,~l obtained
by the read must equal dt~ k~J . . . d~ ,,J with k~ -< . . . -<
kin.
Since l =
maximum(k~ ..... kin),
the result follows
immediately from part (a) of the lemma.
(b) The proof of part (b) is similar, using the
"mirror image" of Theorem 1 and part (b) of the
lemma. []
Applications
We now give some algorithms based upon the
preceding theorems. They will be described by Algol-
like programs, employing some additional notation.
We let : > mean
Set greater than,
in the same way as
:= means
set equal to.
Our algorithms will use m-digit
numbers. The value of m is unspecified, but it is
assumed to be the same for all variables in a single
algorithm. The order in which the digits of a multidigit
808
variable are to be read or written is indicated by an
arrow over the variable occurrence. Thus execution of
the statement
if~
=ythenz :>zfi
reads the variable x by reading its digits from left to
right, reads y by reading its digits in any order, and
tests if the two values obtained are equal. If they are,
then it sets z equal to some undetermined number
greater than its prtvious value:, writing the individual
digits from right to left. (Our algorithms will not allow
a variable to be set by two different processes, so it
does not matter how the old value of z is read.)
We define the statement
wait until condition
to be equivalent to the following waiting loop:
L: if not
condition
then goto
L ft.
We will also use a
repeat
body
until
condition
loop, which has the obvious meaning.
Most of the following algorithms use Theorem 2,
so they require variables that can have arbitrarily large
values. However, practical considerations will always
allow a bound to be placed on these values. For
example, a variable whose value equals the current
year is theoretically unbounded, but it can be satisfac-
torily implemented with four decimal digits.
General Readers/Writer Solution
We first give a simple solution to the general
readers/writers problem in the case of a single writer.
The basic idea is to let processes read or write at any
time. After reading, a process checks to see if it might
have obtained an incorrect value, in which case it
repeats the operation. The algorithm might be used if
either (i) it is undesirable to make the writer wait for a
reader to finish reading, or (ii) the probability of
having to repeat a read is small enough so that it does
not pay to incur the overhead of a solution employing
mutual exclusion. Of course, it allows the possibility of a
reader looping forever if writing is done often enough.
The reader (of this paper) should convince himself
that finding such a solution is a nontrivial problem.
For example, a simple "I am writing" flag will not
work. Our algorithm maintains two version numbers
for the data: vl and v2. The writer increments vl
before writing the data item and increments v2 after
writing. The reader reads v2 before reading the data
item and vl after reading it. If it finds them equal,
then it knows that it read a single version of the data.
We let vl and v2 be multidigit common variables,
and assume that initially vl = v2. The algorithms for
reading and writing are given below. There may be
any number of readers, each executing its own copy of
the readers' algorithm. The writing algorithm may only
be executed by one writer at a time.
Communications November 1977
of Volume 20
the ACM Number 11
writer reader
vl :> vl;
repeat temp :=
v2;
write; read
v2 : = vl until
~ = temp
We now prove that the algorithm is correct. Let D
denote the data item which is being read and written,
and let v2 tk,,zl~, Dt~2.s j, vltks,t3 ~ denote the values of v2,
D, vl read by a reader during a single iteration of the
reading loop. We must show that if the reader decides
not to read again, then this read of D obtained a
correct value; i.e. we must show that if v2 tkt,hl =
vl tk3,/~J, then ks = Is.
Applying Theorem 2 to the reading and writing of
vl and v2, we obtain
v2 tk~'~,l -< v2 tz,j and vl t~ ~
vl [ka'/a].
(1)
Applying Theorem 1 to v2 D vl, we see that
kl -< ll --- k2-< 12-< k3-< 13. (2)
Since v2 t°l = vl t°l, examination of the writing algorithm
shows that 11 -< k3 implies v2 tzlJ _< vl tk~l, and equality
holds if and only if 11 = k3. Combining this inequality
with (1), we obtain
V2tk,,l~] < v2tt~] __< vltk3] __< vltk~.t3].
Hence, v2 tkl,z,J = vltk3.za I implies that v2 ull = vl tk3j,
which in turn implies that ll = k3. By (2), this implies
that kz = 12, completing the proof of correctness.
Note that the converse is not true. We could have
k2 =
12 even though
V2 tk~'tl] :/: vltk3'/31;
i.e. a reader
could decide to read again even though it actually
obtained a correct version of D.
If reading D is an expensive operation, then the
reader's
temp
:= v-'-2' statement should be changed to
4---
repeat
temp
:= v2 until vl =
temp.
This keeps a reader from performing a read operation
if the writer has already begun writing.
Suppose we know that at most P write operations
can occur during a single iteration of the reading loop,
and a single digit can assume P + 1 distinct values.
Then we can let vl and v2 be single-digit variables
which cycle through P + 1 or more values rather than
assuming a (theoretically) unbounded number of dif-
ferent values. However, if D is a data file kept in
secondary storage, then it is likely to have a version
number (or creation date) associated with it anyway.
The algorithm just requires maintaining an extra copy
of this version number.
A method similar to our algorithm was introduced
in [4]. However, it uses a single version number and
assumes that reading is inhibited while writing is in
progress. A referee has pointed out that similar appli-
cations also appear in [7] and [8].
809
Message Buffer
We now consider the problem of transmitting mes-
sages from one process to another. Assume that there
is a sender process which transmits a sequence of
messages to a receiver process. The sender deposits
the messages one at a time in a buffer, and the receiver
reads them from the buffer one at a time. Assume a
buffer B which can hold P messages in locations B [0],
...,B[P -
1]. If the buffer is empty, then the
receiver must wait for the next message to arrive. If
the buffer is full, then the sender must wait until the
receiver empties a buffer position by reading the mes-
sage in it. This is also known as the producer/consumer
problem [2].
The following solution uses multidigit variables
ms
and
mr
to hold the total number of messages sent and
received, respectively. We assume that they are both
initialized to zero.
sender
wait until ms
< ~rr + P;
put message in B[ms
rood/5];
ms := ms + 1
receiver
wait until mr < ms;
read message in B[mr
rood
P];
mr := mr
W ]
The algorithm is quite straightforward, and its
correctness is clear if the values of
mr
read by the
sender and of
ms
read by the receiver are always
correct. It is also easy to see that the algorithm is still
correct if the values obtained by these reads are always
less than or equal to the correct values, and part (a) of
Theorem 2 guarantees that this is true. (Note that the
sender always reads the correct value of
ms
and the
receiver always reads the correct value of mr.)
If a digit can assume 2P distinct values, then this
solution can be modified to make
mr and ms
single
digit variables. The resulting algorithm, and a proof of
its correctness, can be found in [6].
Mailbox
In the preceding algorithm, a message which has
been sent is not destroyed until it has been received.
This is undesirable if a process may want to cancel an
unreceived message. For example, suppose the mes-
sage is "I want to write file X." The sender would like
to cancel this message when it has finished writing.
Using the preceding algorithm, it could simply transmit
the message "I no longer want to write file X."
However, this is unsatisfactory because the sender
may have to wait for the receiver to empty the message
buffer. The receiver should not have to look at that
message buffer unless it wishes to use file X.
For such cases we want a
mailbox
that holds one
message which can be written and rewritten by the
sender, and read by the receiver. We are not concerned
Communications November 1977
of Volume 20
the ACM Number 11
with insuring that the receiver reads a correct version
of the mailbox. If that is necessary, it can be done with
any solution to the reader/writer problem, such as the
one given above. Instead we will only consider the
problem of letting the sender know that the current
message in the mailbox has been received. For exam-
pie, knowing that an "I want to write file X" message
was received may allow a process to safely write file X.
This problem is easily solved by implementing
mutual exclusion of accesses to the mailbox. However,
mutual exclusion can be avoided by using the following
technique. The sender writes a unique message number
in the variable
msg.uo,
and the receiver puts the
number of the message it has just read into the variable
msg.rd.
More precisely, the following algorithms are
used for sending and receiving. We assume that
msg.uo
and
msg.rd
are multidigit numbers which are initially
equal to one another.
sender
put message in mailbox;
~nsg.no :> msg.no
receiver
)
temp
:= msg.no;
read message in mailbox;
nlsg.rd :=
temp
To find out if the most recent message has been re-
ceived, the sender performs the following test:
if
msg.no
= msg.rd then most recent message was received ft.
To prove the correctness of this test, let mailbox
denote the mailbox and assume that the receiver reads
the message in mailbox by executing the statement
msg
:= mailbox. Let mailbox u] be the current value of the
mailbox, and let msg.rd tp.q) be the value of
msg.rd
obtained by the sender when executing the testing
statement. We must show that if msg.rd tp,q] =
msg.no u], then the current value of
msg
is mailbox lz]. It
suffices to prove that
msg tq]
= mailbox m, since the fact
that the sender read msg.rd n°. q] implies by premise (ii)
that the receiver has already written
msg lq~.
If the qth
version of
msg
already contained the current version
of mailbox, then any subsequent versions of
msg
must
also contain this version.
The receiving algorithm implies that msg.rd tq] =
msg.nolkl.
11]
and
msg lq]
= mailbox tk~, 12] for some k,, li.
We must show that msg.rd tp, ~] = msg.no u] implies that
k2 = 12 = l. Applying Theorem 1 to the pair of data
items
msg.no, mailbox,
we have
kl
--<
ll ----- k2 ---- lz --< l, (3)
where the last inequality follows from the fact that
mailbox u] is the current value of mailbox. From part
(a) of Theorem 2 and the fact that ll - l, we obtain
msg.rdtp, q] _< msg.rdtq] = msg.notk,, z,~
_<
msg.noU,) _< msg.no tt].
Therefore msg.rd tp, q] =
msg.no
u] implies that
msg.no u,] = msg.no u], which in turn implies that ll =
1. By (3), this shows that kz = 12 =
l,
which completes
the proof.
Note that our algorithm gives the sender a sufficient
810
condition for the current message to have been read,
but not a necessary one. The receiver could have read
the current message and the prior message number, in
which case the sender will not discover that the current
message has been read until the; receiver reads it again.
This limits the applicability of this algorithm.
As an example of how such a mailbox can be used,
we give a new solution to a generalized readers/writer
problem (with a single writer), in which a read (write)
operation consists of reading (writing) from some set
of files. We assume that this set is chosen before the
operation begins. We will insure that a file is not
written while it is being read, so this is a mutual
exclusion approach. A read operation may be per-
formed concurrently with a write operation if it does
not use any of the files being written.
Our solution gives the writer highest priority, so a
reader must wait if it wants to use a file which the
writer is waiting for. This allows the possibility of a
reader waiting forever if writing is done very fre-
quently.
The solution uses a single mailbox which is written
by the writer and read by all the readers. The mailbox
contains a set of file names. The element "X" in the
mailbox represents an "I want to write file X" message.
The variables
msg.rd
and
temp
of our algorithm be-
come arrays. We also use an array r[l:Nl of sets of file
names, where N is the number of readers. We let
mailbox and each r/i] be initially equal to the empty
set, which is denoted by ~b.
The following are the algorithms for the writer and
for reader number i. Note that each program variable
is written by only one process.
writer
mailbox := set of names of files to be written;
msg.no :> msg.no;
for
j := 1 step 1 until N
do
wait until msg.no = msg.rdU] or rli] N
mailbox
= 4,
od;
write;
mailbox
:= q5
ith
reader
rlil := set of names of files to be read;
repeat
temp[i]
:=
msg.n~;
msg[i]
:= mailbox;
msg.rdlil
:=
temp[i]
until
rli] rl
msg[i] = ~;
read;
r[il := tb
We first prove that a file cannot be read while it is
being written. To do this, we assume that the ith
reader is reading and the writer is writing, and show
that this implies r/i] f3 mailbox = ~b. Consider the ith
iteration of the writer's for loop before it began writing.
While executing the
wait until
statement, the writer
must have found (a)
msg.no = msg.rd[i],
or (b) r/i] A
mailbox
= ~b. We consider these two cases separately.
If the writer found (a) to be true, then the correct-
ness of our mailbox algorithm implies that the ith
reader must have read the current value of mailbox.
Communications November 1977
of Volume 20
the ACM Number 11