Download 第七章

Chapter 7: Process Synchronization
 Background
 The Critical-Section Problem
 Synchronization Hardware
 Semaphores
 Classical Problems of Synchronization
 Critical Regions
 Monitors
 Synchronization in Solaris 2 & Windows 2000
Operating System Concepts
7.1
Silberschatz, Galvin and Gagne 2002
Background
 Concurrent access to shared data may result in
data inconsistency.
 Maintaining data consistency requires
mechanisms to ensure the orderly execution of
cooperating processes.
 Shared-memory solution to bounded-butter
problem (Chapter 4) allows at most n – 1 items in
buffer at the same time. A solution, where all N
buffers are used is not simple.
 Suppose that we modify the producerconsumer code by adding a variable counter,
initialized to 0 and incremented each time a
new item is added to the buffer
Operating System Concepts
7.2
Silberschatz, Galvin and Gagne 2002
Bounded-Buffer
 Shared data
#define BUFFER_SIZE 10
typedef struct {
...
} item;
item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
int counter = 0;
Operating System Concepts
7.3
Silberschatz, Galvin and Gagne 2002
Bounded-Buffer
 Producer process
item nextProduced;
while (1) {
while (counter == BUFFER_SIZE)
; /* do nothing */
buffer[in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
counter++;
}
Operating System Concepts
7.4
Silberschatz, Galvin and Gagne 2002
Bounded-Buffer
 Consumer process
item nextConsumed;
while (1) {
while (counter == 0)
; /* do nothing */
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
counter--;
}
Operating System Concepts
7.5
Silberschatz, Galvin and Gagne 2002
Bounded Buffer
 The statements
counter++;
counter--;
must be performed atomically.(原子地)
 Atomic operation means an operation that
completes in its entirety without interruption. (原
子操作)
Operating System Concepts
7.6
Silberschatz, Galvin and Gagne 2002
Bounded Buffer
 The statement “count++” may be implemented in
machine language as:
register1 = counter
register1 = register1 + 1
counter = register1
 The statement “count—” may be implemented as:
register2 = counter
register2 = register2 – 1
counter = register2
Operating System Concepts
7.7
Silberschatz, Galvin and Gagne 2002
Bounded Buffer
 If both the producer and consumer attempt to
update the buffer concurrently, the assembly
language statements may get interleaved.
 Interleaving depends upon how the producer
and consumer processes are scheduled.
Operating System Concepts
7.8
Silberschatz, Galvin and Gagne 2002
Bounded Buffer
 Assume counter is initially 5. One interleaving of
statements is:
producer: register1 = counter (register1 = 5)
producer: register1 = register1 + 1 (register1 = 6)
consumer: register2 = counter (register2 = 5)
consumer: register2 = register2 – 1 (register2 = 4)
producer: counter = register1 (counter = 6)
consumer: counter = register2 (counter = 4)
 The value of count may be either 4 or 6, where the
correct result should be 5.
Operating System Concepts
7.9
Silberschatz, Galvin and Gagne 2002
Another example
two processes p0,p1, share a variable:int
total(initialized as 0 ) ;
Both of them execute the following program
concurrently:
p0,p1:
{
int count;
for (count=1; count <=50; count++)
total = total + 1 ;
}
Question: what is the probable result of “total”?(upper limit
and lower limit)
Operating System Concepts
7.10
Silberschatz, Galvin and Gagne 2002
Race Condition
 Race condition: The situation where several
processes access – and manipulate shared
data concurrently. The final value of the shared
data depends upon how these processes
interleave.
 To prevent race conditions, concurrent
processes must be synchronized.
Operating System Concepts
7.11
Silberschatz, Galvin and Gagne 2002
The Critical-Section Problem
 n processes all competing to use some shared
data
 The shared data can be accessed only by one
process at a time(we call this kind of data as
“critical resource”)
 Each process has a code segment, called
critical section, in which the shared data is
accessed.
 Problem – ensure that when one process is
executing in its critical section, no other process
is allowed to execute in its critical section.
Operating System Concepts
7.12
Silberschatz, Galvin and Gagne 2002
Solution to Critical-Section Problem
Three requirements must be satisfied: （三个必须）
1. Mutual Exclusion. If process Pi is executing in its critical
section, then no other processes can be executing in their
critical sections.(每次最多只有一个进程在CS)
2. Progress. If no process is executing in its critical section and
there exist some processes that wish to enter their critical
section, then the selection of the processes that will enter the
critical section next cannot be postponed indefinitely.(没有进
程在CS,若有多个进程申请进入CS，应在有限时间内让其中之一
进入，而不应互相阻塞，以至于各进程都无法进入)
3. Bounded Waiting. A bound must exist on the number of times
that other processes are allowed to enter their critical sections
after a process has been admitted to enter its critical section.
No starvation(进程允许进入CS后,将在有限时间内离开CS并允许
其他进程进入)
Two assumptions（二个前提）
 Assume that each process executes at a nonzero speed
 No assumption concerning relative speed of the n processes.
Operating System Concepts
7.13
Silberschatz, Galvin and Gagne 2002
Methods to solve the CS Problem
1. Software solution. To solve the CS problem by the user
processes themselves. No need of operating system
support or special programming language.
2. Hardware support. To rely on special hardware support (
e.g. interrupt disabling, special machine instructions)
3. Operating System support. OS provides
services(usually system calls) to solve the CS problem.
Operating System Concepts
7.14
Silberschatz, Galvin and Gagne 2002
Software solution: Initial Attempts to
Solve Problem
 Only 2 processes, P0 and P1
 General structure of process Pi (other process Pj)
do {
entry section
critical section
exit section
remainder section
} while (1);
 Processes may share some common variables to
synchronize their actions.
 Entry section: code requesting for entering CS
 Exit section: code releasing resources
Operating System Concepts
7.15
Silberschatz, Galvin and Gagne 2002
Algorithm 1
 Shared variables:
int turn;
initially turn = 0
turn = i  Pi can enter its critical
section
 Process Pi
do {
while (turn != i) ;
critical section
turn = j;
reminder section
} while (1);
 Satisfies mutual exclusion, but not progress(必须交替进入
)
Operating System Concepts
7.16
Silberschatz, Galvin and Gagne 2002
Algorithm 2
 Shared variables
boolean flag[2];
initially flag [0] = flag [1] = false.
flag [i] = true  Pi ready to enter its
critical section
 Process Pi
do {
flag[i] := true;
while (flag[j]) ;
critical section
flag [i] = false;
remainder section
} while (1);
 Satisfies mutual exclusion, but not progress requirement.(
互相谦让)
Operating System Concepts
7.17
Silberschatz, Galvin and Gagne 2002
Algorithm 3(Peterson)
 Combined shared variables of algorithms 1 and 2.
 Process Pi
do {
flag [ i ]:= true;
turn = j;
while (flag [ j ] and turn = j) ;
critical section
flag [ i ] = false;
remainder section
} while (1);
 Meets all three requirements; solves the critical-section
problem for two processes.
Operating System Concepts
7.18
Silberschatz, Galvin and Gagne 2002
Proof of Algorithm 3
 Mutual exclusion
1. Pi and Pj can enter CS almost simultaneously only if
turn=i and turn=j (impossible)
2. If Pi entered CS in advance, Pj must be loop in while
 Progress
1. If only Pi wants to enter CS, Pj does not want to enter CS,
then flag[ j ] = false. Pi will enter CS immediately.
2. If Pi and Pj all want to enter CS, they cannot both be
blocked in loop(turn = i or turn = j)
 Bounded-waiting
If Pj exits CS, it will reset flag[ j ]=false. If Pj has time to set
flag[ j ]=true, it must also set turn = j, allowing Pi to enter CS.
Operating System Concepts
7.19
Silberschatz, Galvin and Gagne 2002
Bakery’s Algorithm
Critical section for n processes
 Before entering its critical section, process
receives a number. Holder of the smallest
number enters the critical section.
 If processes Pi and Pj receive the same number,
if i < j, then Pi is served first; else Pj is served
first.
 The numbering scheme always generates
numbers in increasing order of enumeration;
i.e., 1,2,3,3,3,3,4,5...
Operating System Concepts
7.20
Silberschatz, Galvin and Gagne 2002
Bakery’s Algorithm (cont.)
 Notation ： lexicographical order (ticket #,
process id #)
 (a,b) < (c,d) if a < c or if a = c and b < d
 max (a0,…, an-1) is a minimum number, k, such
that k  ai for i = 0,
…, n – 1
 Shared data
boolean choosing[n];
int number[n];
Data structures are initialized to false and 0
respectively
Operating System Concepts
7.21
Silberschatz, Galvin and Gagne 2002
Bakery’s Algorithm (cont.)
do {
choosing[i] = true;
number[i] = max(number[0], number[1], …, number [n – 1])+1;
choosing[i] = false;
for (j = 0; j < n; j++) {
while (choosing[j]) ;
while (number[j] != 0 && (number[j],j) < (number[i],i)) ;
}
critical section
number[i] = 0;
remainder section
} while (1);
Operating System Concepts
7.22
Silberschatz, Galvin and Gagne 2002
Synchronization Hardware
 Disabling interrupt: sometimes impossible(e.g. clock
interrupt, SMP)
 Test-and-set instruction: Test and modify the content of a
word atomically
.
boolean TestAndSet(boolean &target) {
boolean rv = target; // test first
tqrget = true;
// set next
return rv;
}
Operating System Concepts
7.23
Silberschatz, Galvin and Gagne 2002
Mutual Exclusion with Test-and-Set
 Shared data:
boolean lock = false;
 Process Pi
do {
while (TestAndSet(lock)) ;
critical section
lock = false;
remainder section
}
Operating System Concepts
7.24
Silberschatz, Galvin and Gagne 2002
Synchronization Hardware
 Swap instruction: Atomically swap two
variables.
void Swap(boolean &a, boolean &b) {
boolean temp = a;
a = b;
b = temp;
}
Operating System Concepts
7.25
Silberschatz, Galvin and Gagne 2002
Mutual Exclusion with Swap
-- No bounded-waiting
 Shared data (initialized to false):
boolean lock;
 Process Pi
do {
key = true;
while (key == true) //获得lock值为false的进程能进入
Swap(lock,key);
critical section
lock = false;
remainder section
}
Operating System Concepts
7.26
Silberschatz, Galvin and Gagne 2002
Hardware solution features




No limit on processes and CPUs
Simple and easy to verify
Busy-waiting is required
May cause starvation(do not satisfy bounded-waiting):
selection of ready process to run is arbitrarily
Operating System Concepts
7.27
Silberschatz, Galvin and Gagne 2002
Mutual Exclusion with TestAndSet
-- Bounded-waiting
 Shared data (initialized to false):
boolean lock;
boolean waiting[n];
 Process Pi
Operating System Concepts
do {
waiting[ i ] = true;
key = true;
while (waiting[ i ] && key)
key = TestAndSet(lock);
waiting[ i ] = false;
critical section
j = ( i + 1) % n;
while(( j != i) && !waiting[ j ])
j = ( j + 1 ) %n;
if ( j == i )
lock = false;
else
waiting[ j ] = false;
remainder section
Silberschatz, Galvin and
7.28
}
Gagne 2002
Operating system support: Semaphores
 Synchronization tool that does not require busy waiting.
 Semaphore S – integer variable
 can only be accessed via two indivisible (atomic)
operations
wait (S): //(也叫P操作)
while S 0 do no-op;
S--;
signal (S): //(也叫V操作)
S++;
Operating System Concepts
7.29
Silberschatz, Galvin and Gagne 2002
Critical Section of n Processes
 Shared data:
semaphore mutex; //initially mutex = 1
 Process Pi:
do {
wait(mutex);
critical section
signal(mutex);
remainder section
} while (1);
Operating System Concepts
7.30
Silberschatz, Galvin and Gagne 2002
Semaphore Implementation
 Define a semaphore as a record
typedef struct {
int value;
struct process *queue;
} semaphore;
 Assume two simple operations:
 block suspends the process that invokes it.
 wakeup(P) resumes the execution of a blocked
process P.
Operating System Concepts
7.31
Silberschatz, Galvin and Gagne 2002
Implementation
 Semaphore operations now defined as
wait(S):
S.value- -;
if (S.value < 0) {
add this process to S.queue;
block;
}
signal(S):
S.value++;
if (S.value <= 0) {
remove a process P from
S.queue;
wakeup(P);
}
Operating System Concepts
7.32
Silberschatz, Galvin and Gagne 2002
Semaphore as a General Synchronization Tool
 Execute B in Pj only after A executed in Pi
 Use semaphore flag initialized to 0
 Code:
Pi

A
signal(flag)
Operating System Concepts
Pj

wait(flag)
B
7.33
Silberschatz, Galvin and Gagne 2002
Deadlock and Starvation
 Deadlock – two or more processes are waiting
indefinitely for an event that can be caused by only one of
the waiting processes.
 Let S and Q be two semaphores initialized to 1
P0
P1
wait(S);
wait(Q);
wait(Q);
wait(S);


signal(S);
signal(Q);
signal(Q)
signal(S);
 Starvation – indefinite blocking. A process may never
be removed from the semaphore queue in which it is
suspended.
Operating System Concepts
7.34
Silberschatz, Galvin and Gagne 2002
Two Types of Semaphores
 Counting semaphore – integer value can
range over an unrestricted domain.
 Binary semaphore – integer value can range
only between 0 and 1; can be simpler to
implement.
 Can implement a counting semaphore S
using binary semaphores.
Operating System Concepts
7.35
Silberschatz, Galvin and Gagne 2002
Binary semaphores(Mutex)
waitB(S):
if (S.value = 1) {
S.value := 0;
} else {
block this process
place this process in S.queue
}
signalB(S):
if (S.queue is empty) {
S.value := 1;
} else {
remove a process P from S.queue
place this process P on ready list
}
Operating System Concepts
7.36
Silberschatz, Galvin and Gagne 2002
Implementing S using Binary Semaphores
 Data structures:
binary-semaphore S1, S2;
int C:
 Initialization:
S1 = 1
S2 = 0
C = initial value of semaphore S
Operating System Concepts
7.37
Silberschatz, Galvin and Gagne 2002
Implementing S
 wait operation
wait(S1);
C--;
if (C < 0) {
signal(S1);
wait(S2);
}
signal(S1);
 signal operation
wait(S1);
C ++;
if (C <= 0)
signal(S2);
else
signal(S1);
Operating System Concepts
7.38
Silberschatz, Galvin and Gagne 2002
Classical Problems of Synchronization
 A semaphore represents a shared data, its
initialized value is the number of processes that
can access the shared data simultaneously(一
个信号量代表一个共享资源，其初值表示可以同
时访问该共享资源的进程数)
 Bounded-Buffer Problem
 Readers and Writers Problem
 Dining-Philosophers Problem
Operating System Concepts
7.39
Silberschatz, Galvin and Gagne 2002
Bounded-Buffer Problem
 Shared data
semaphore full, empty, mutex;
Initially:
full = 0, empty = n, mutex = 1
Operating System Concepts
7.40
Silberschatz, Galvin and Gagne 2002
Bounded-Buffer Problem Producer
Process
do {
…
produce an item in nextp
…
wait(empty);
wait(mutex);
…
add nextp to buffer
…
signal(mutex);
signal(full);
} while (1);
Operating System Concepts
do {
wait(full)
wait(mutex);
…
remove an item from buffer to nextc
…
signal(mutex);
signal(empty);
…
consume the item in nextc
…
} while (1);
7.41
Silberschatz, Galvin and Gagne 2002
Bounded-Buffer Problem Consumer
Process
do {
wait(full)
wait(mutex);
…
remove an item from buffer to nextc
…
signal(mutex);
signal(empty);
…
consume the item in nextc
…
} while (1);
Operating System Concepts
7.42
Silberschatz, Galvin and Gagne 2002
Readers-Writers Problem
 Problem description: 读者只能读取共享数据，写者可以读
写共享数据。写者只有一人，读者可以有多人。读者和写
者不能共存
 Shared data
semaphore mutex
semaphore wrt;
//互斥访问readcount
//读者和写者不能共存
Initially
mutex = 1, wrt = 1, readcount = 0 //读者人数
Operating System Concepts
7.43
Silberschatz, Galvin and Gagne 2002
Readers-Writers Problem Writer Process
wait(wrt);
//申请进入
…
writing is performed
…
signal(wrt);
//离开
Operating System Concepts
7.44
Silberschatz, Galvin and Gagne 2002
Reader Process
writer: wait(wrt);
//申请进入
…
writing is performed
…
signal(wrt);
//离开
reader:wait(mutex);
//申请访问readcount
readcount++;
if (readcount == 1) //如果是第一个读者，禁止写者进入
wait(wrt);
signal(mutex); //释放访问readcount的锁
…
reading is performed
…
wait(mutex);
//申请访问readcount
readcount--;
if (readcount == 0) //如果没有读者了，应该允许写者进入
signal(wrt);
signal(mutex): //释放访问readcount的锁
Operating System Concepts
7.45
Silberschatz, Galvin and Gagne 2002
Dining-Philosophers Problem
 Shared data
semaphore chopstick[5]:=1, count := 4
Operating System Concepts
7.46
Silberschatz, Galvin and Gagne 2002
Dining-Philosophers Problem
 Philosopher i:
do {
wait(count);
wait(chopstick[i])
//want to pick up left
chopstick
wait(chopstick[(i+1) % 5]) //the right one
…
eat
…
signal(chopstick[i]);
//release left
signal(chopstick[(i+1) % 5]);//release right
signal(count);
…
think
…
} while (1);
Operating System Concepts
7.47
Silberschatz, Galvin and Gagne 2002
例题
有n个进程（P1，P2，…，Pn）向容量为M的缓冲区写数据，每个进程一次写1
个数据，当缓冲区写满时，另一个读进程Pr一次将M个数据全部读完，如此反复。
请用信号量解决这些进程的同步互斥问题。
答：本题中需要定义下述变量和信号量：
data_type buffer[M]; /* data_type对应于所需要的数据类型，如int、float等 */
int in=0； /* 用来指示下一个可存放数据的缓冲区 */
semaphore empty=M; /* 对应空闲的缓冲区 */
semaphore full=0; /* 对应缓冲区中的数据 */
semaphore mutex=1; /* 用来实现Pi进程对变量in的互斥访问 */
进程Pi可描述为：
Pi(){
while(1){
P(empty);
P(mutex);
向缓冲区buffer[in]中写数据；
in=(in+1)%M; V(mutex);
V(full); } }
进程Pr可描述为：
Pr(){
int i;
while(1){
for(i=0;i<M;i++) P(full);
取出缓冲buffer[0]到buffer[M-1]中的数据；
for(i=0;i<M;i++) V(empty); } }
Operating System Concepts
7.48
Silberschatz, Galvin and Gagne 2002
思考题
 有一个仓库存放两种零件A和B，最大库容量各为m
个。有一车间不断地取A和B进行装配，每次各取一
个。有两种供应商分别不断地供应A和B。为保证齐
套和合理库存，当某种零件的数量比另一种的数量超
过n(n<m)个时，暂停对数量大的零件进货，集中补
充数量少的零件。试用信号量正确地实现之。
Operating System Concepts
7.49
Silberschatz, Galvin and Gagne 2002
Unix Semaphores
 Are a generalization of the counting semaphores (more




operations are permitted).
A semaphore includes:
 the current value S of the semaphore(non-negative
integer)
 number of processes waiting for S to increase
 number of processes waiting for S to be 0
We have queues of processes that are blocked on a
semaphore
The system call semget creates an array of semaphores
The system call semop performs a list of operations: one
on each semaphore (atomically)
Operating System Concepts
7.50
Silberschatz, Galvin and Gagne 2002
Unix Semaphores
 Each operation to be done is specified by a value sem_op.
 Let S be the semaphore value
 if sem_op > 0:
S is incremented and process awaiting for S to
increase are awaken
 if sem_op = 0:
If S=0: do nothing
if S!=0, block the current process on the event that
S=0
Operating System Concepts
7.51
Silberschatz, Galvin and Gagne 2002
Unix Semaphores
 if sem_op < 0 and |sem_op| <= S:
set S:= S + sem_op (ie: S decreases)
then if S=0: awake processes waiting for S=0
 if sem_op < 0 and |sem_op| > S:
current process is blocked on the event that S
increases
 Hence: flexibility in usage (many operations are permitted)
Operating System Concepts
7.52
Silberschatz, Galvin and Gagne 2002
Critical Regions(临界域)
 High-level synchronization construct
 A shared variable v of type T, is declared as:
v: shared T
 Variable v accessed only inside statement
region v when B do S
where B is a boolean expression.
 While statement S is being executed, no other
process can access variable v.
Operating System Concepts
7.53
Silberschatz, Galvin and Gagne 2002
Critical Regions
 Regions referring to the same shared variable
exclude each other in time.
 When a process tries to execute the region
statement, the Boolean expression B is
evaluated. If B is true, statement S is executed.
If it is false, the process is delayed until B
becomes true and no other process is in the
region associated with v.
Operating System Concepts
7.54
Silberschatz, Galvin and Gagne 2002
Example – Bounded Buffer
 Shared data:
struct buffer {
int pool[n];
int count, in, out;
}
Operating System Concepts
7.55
Silberschatz, Galvin and Gagne 2002
Bounded Buffer Producer Process
 Producer process inserts nextp into the shared
buffer
region buffer when( count < n) {
pool[in] = nextp;
in:= (in+1) % n;
count++;
}
Operating System Concepts
7.56
Silberschatz, Galvin and Gagne 2002
Bounded Buffer Consumer Process
 Consumer process removes an item from the
shared buffer and puts it in nextc
region buffer when (count > 0) {
nextc = pool[out];
out = (out+1) % n;
count--;
}
Operating System Concepts
7.57
Silberschatz, Galvin and Gagne 2002
Implementation region x when B do S
 Associate with the shared variable x, the following
variables:
semaphore mutex, first-delay, second-delay;
int first-count, second-count;
 Mutually exclusive access to the critical section is
provided by mutex.
 If a process cannot enter the critical section because the
Boolean expression B is false, it initially waits on the
first-delay semaphore; moved to the second-delay
semaphore before it is allowed to reevaluate B.
Operating System Concepts
7.58
Silberschatz, Galvin and Gagne 2002
Implementation
 Keep track of the number of processes waiting
on first-delay and second-delay, with firstcount and second-count respectively.
 The algorithm assumes a FIFO ordering in the
queuing of processes for a semaphore.
 For an arbitrary queuing discipline, a more
complicated implementation is required.
Operating System Concepts
7.59
Silberschatz, Galvin and Gagne 2002
Monitors(管程)
 High-level synchronization construct that allows the safe sharing
of an abstract data type among concurrent processes.
monitor monitor-name
{
shared variable declarations
procedure body P1 (…) {
...
}
procedure body P2 (…) {
...
}
procedure body Pn (…) {
...
}
{
initialization code
}
}
Operating System Concepts
7.60
Silberschatz, Galvin and Gagne 2002
Monitors
 Only one process at a time can be active within the monitor
 To allow a process to wait within the monitor, a condition
variable must be declared, as
condition x, y;
 Condition variable can only be used with the operations wait
and signal.
 The operation
x.wait();
means that the process invoking this operation is suspended
until another process invokes
x.signal();
 The x.signal operation resumes exactly one suspended
process. If no process is suspended, then the signal
operation has no effect.
Operating System Concepts
7.61
Silberschatz, Galvin and Gagne 2002
Monitor
 Awaiting processes are either





in the entrance queue or in a
condition queue
A process puts itself into
condition queue cn by issuing
cwait(cn)
csignal(cn) brings into the
monitor 1 process in condition
cn queue
Hence csignal(cn) blocks the
calling process and puts it in
the urgent queue (unless
csignal is the last operation of
the monitor procedure)
cwait(cn) equals to cn.wait()
csignal(cn)equals to cn.signal()
Operating System Concepts
7.62
Silberschatz, Galvin and Gagne 2002
Schematic View of a Monitor
Operating System Concepts
7.63
Silberschatz, Galvin and Gagne 2002
Monitor With Condition Variables
Operating System Concepts
7.64
Silberschatz, Galvin and Gagne 2002
Dining Philosophers Example
monitor dp
{
enum {thinking, hungry, eating} state[5];
condition self[5];
void pickup(int i)
void putdown(int i)
void test(int i)
void init() {
for (int i = 0; i < 5; i++)
state[i] = thinking;
}
}
Operating System Concepts
7.65
Silberschatz, Galvin and Gagne 2002
void pickup(int i) {
state[i] = hungry;
test[i];
Philosopher i:
…
if (state[i] != eating)
dp.pickup(i);
self[i].wait();
…
}
eat
void putdown(int i) {
…
state[i] = thinking;
dp.putdown(i);
// test left and right neighbors
test((i+4) % 5);
test((i+1) % 5);
No deadlock
}
May cause starvation
void test(int i) {
if ( (state[(i + 4) % 5] != eating) &&
(state[i] == hungry) &&
(state[(i + 1) % 5] != eating)) {
state[i] = eating;
self[i].signal();
}
}
Operating System Concepts
7.66
Silberschatz, Galvin and Gagne 2002
Monitor Implementation Using Semaphores
 Variables
semaphore mutex; // (initially = 1)
semaphore next; // (initially = 0)
int next-count = 0; //让位的进程数
 Each external procedure F will be replaced by
wait(mutex); //进入monitor
…
body of F;
…
if (next-count > 0) //离开前看有没有让
位进程，如有，激活它们中的一个，不让其他进程进入，
否则，释放mutex,让其他一个进程进入
signal(next)
else
signal(mutex);
 Mutual exclusion within a monitor is ensured.
Operating System Concepts
7.67
Silberschatz, Galvin and Gagne 2002
Monitor Implementation
 For each condition variable x, we have:
semaphore x-sem; // (initially = 0)
int x-count = 0;
//等待条件x的进程数
 The operation x.wait can be implemented as:
x-count++;
if (next-count > 0) //在进入等待队列前，看
有没有让位进程，如有，激活其中的一个，不让其他进程
进入，否则，释放mutex,让其他一个进程进入
signal(next);
else
signal(mutex);
wait(x-sem);
x-count--;
Operating System Concepts
7.68
Silberschatz, Galvin and Gagne 2002
Monitor Implementation
 The operation x.signal can be implemented as:
if (x-count > 0) {
next-count++; //自己变为让位进程
signal(x-sem); //释放等待队列中的一个进程
wait(next);
//自己进入让位进程队列
next-count--; //从让位进程队列出来，继续
执行
}
//如果没有等待该条件的进程，什么也不
做
Operating System Concepts
7.69
Silberschatz, Galvin and Gagne 2002
Monitor Implementation
 Conditional-wait construct: x.wait(c);
 c – integer expression evaluated when the wait operation
is executed.
 value of c (a priority number) stored with the name of the
process that is suspended.
 when x.signal is executed, process with smallest
associated priority number is resumed next.
 Check two conditions to establish correctness of system:
 User processes must always make their calls on the
monitor in a correct sequence.
 Must ensure that an uncooperative process does not
ignore the mutual-exclusion gateway provided by the
monitor, and try to access the shared resource directly,
without using the access protocols.
Operating System Concepts
7.70
Silberschatz, Galvin and Gagne 2002
Solaris 2 Synchronization
 Implements a variety of locks to support
multitasking, multithreading (including real-time
threads), and multiprocessing.
 Uses adaptive mutexes for efficiency when
protecting data from short code segments.
 Uses condition variables and readers-writers locks
when longer sections of code need access to data.
 Uses turnstiles(十字转门) to order the list of
threads waiting to acquire either an adaptive mutex
or reader-writer lock.
Operating System Concepts
7.71
Silberschatz, Galvin and Gagne 2002
Windows 2000 Synchronization
 Uses interrupt masks to protect access to global
resources on uniprocessor systems.
 Uses spinlocks(旋转锁) on multiprocessor
systems.
 Also provides dispatcher objects which may act
as mutexes and semaphores.
 Dispatcher objects may also provide events. An
event acts much like a condition variable.
Operating System Concepts
7.72
Silberschatz, Galvin and Gagne 2002
Spin lock
 Spin lock(旋转锁) on multiprocessor systems.
× 利用busy waiting 而非blocking来阻止进程前进；
× CPU不会去做其他事情，虽然浪费了部分CPU时间，但
省去了进程切换；
× 适合短代码的加锁
wait(S):
S--;
while S<0 do{};
signal(S):
S++;

与spin lock相对应的就是suspend lock（挂起锁），即一般
的锁，会挂起（阻塞）进程的执行
Operating System Concepts
7.73
Silberschatz, Galvin and Gagne 2002
Exercises
 7.3
if Pi in CS, and Pk has chosen number[k]
then (number[I],I) < (number[k],k)
(1) Pk选择number时，Pi已经在CS，则number[k]>number[I]
(2) Pk选择number时，Pi未进入CS
A)Pi正在执行for循环，则number[I]<number[k]
B)Pi未执行for循环，则(number[k],k)>(number[I],I)，否则
Pi无法进入
Operating System Concepts
7.74
Silberschatz, Galvin and Gagne 2002
7.4Dekker算法
while(1) {
flag[ i ] = true;
while (flag[j]) {
if (turn==j) {
flag[ i ] = false;
while ( turn == j );
flag[ i ] = true;
}
Exercises
1.互斥(mutual exclusion)
A) Pi和Pj不可能同时进入CS：
turn==j 和turn==I不会同时满足
B)一个进程(如Pi)先进入CS,则flag[ i ]为
true,则Pj无法进入
2.前进(progress）
A)Pi申请进入，Pj不想进入，则flag[ i
]==false,Pi顺利进入
B)Pi和Pj都想进入，则turn==j时Pj进入，
turn==i时Pi进入
}
3.有限等待(bounded waiting)
CS
Pi离开CS后，置turn=j,flag[ i ]=false,这
时Pj可以进入，如果Pj没有进入，Pi又执行
了falg[ i ]=true,则由于turn==j，所以Pi无
法进入，而Pj可以进入
turn = j;
flag[ i ] = false;
RS
}
Operating System Concepts
7.75
Silberschatz, Galvin and Gagne 2002
Exercises
1.互斥(mutual exclusion)
7.5Eisenberg and McGuire’s algorithm
A) 两个进程Px和Py不可能同时进入CS：
While(1) {
while(1) {
turn==x 和turn==y不会同时满足，故Px和Py
的两个if 条件不会都满足
flag[i] = want_in;
j = turn;
while (j !=i) {
if (flag[j]!=idle) j = turn
B)一个进程(如Px)先进入CS,则turn==x，
flag[turn]==in_cs,则其他进程无法进入
2.前进(progress）
else j = (j+1)%n;
}
flag[i] =in_cs; j = 0;
while ((j<n)&&(j ==i || flag[j]!=in_cs)
A)Px申请进入，其他进程不想进入，则其他进
程flag均为idle,则Px的j>=n成立，if条件成立，
跳出while，进入CS
j ++ ;
B)若干进程想进入，如Pturn也想进入，则
if ((j>=n)&&(turn==i||flag[turn]==idle)) Pturn优先进入；否则，编号在turn后的最小号
break;
的想进入的进程进入CS
}
turn = i ;
3.有限等待(bounded waiting)
CS
j = (turn+1)%n;
while(flag[j]==idle) j=(j+1)%n;
turn=j; flag[i]=idle;
} Operating System Concepts
RS
Pi离开CS时，置turn为想进入的进程中大于
turn的最小欲进入之进程号，该进程就进入。
进程Pk不会饿死，最多等待（k-turn)个进程的
CS执行
Silberschatz, Galvin and Gagne 2002
7.76
Exercises
7.9抽烟问题
Semaphore smoker[3];
Semaphore material[3];
Semaphore agent;
Int turn;
//初始0，三个抽烟者
//初始0，三种原料
//初始1，供应商
//初始0，轮到谁
Agent:
While(1){
wait(agent);
signal(smoker[turn]);
signal(material[(turn+1)%3]);
signal(material[(turn+2)%3]);
turn= (turn+1)%3;
}
Smoker-i:
While(1){
wait(smoker[i]);
wait(material[(i+1)%3]);
wait(material[(i+2)%3]);
signal(agent);
}
Operating System Concepts
7.77
Silberschatz, Galvin and Gagne 2002
7.11
Exercises
Monitor bounded_buffer
{
item pool[n];
int count, in, out;
Producer process:
While(1) {
produce an item;
bounded_buffer.put_item();
}
condition full, empty;
void get_item()
{
if (count==0) full.wait();
get_from_buffer();
count--;
empty.signal();
}
void put_item()
{
if (count==n) empty.wait();
put_to_buffer();
count++;
full.signal();
}
void init() { count=in=out=0;}
Consumer process:
While (1) {
bounded_buffer.get_item();
consume the item;
}
}
Operating System Concepts
7.78
Silberschatz, Galvin and Gagne 2002
Exercises
7.8 理发问题
Semaphore max;
//初始n+1,表示理发店可以容纳总人数
Semaphore chair;
//初始n，空闲的椅子
Semaphore barber; //初始1，表示理发椅空闲
Semaphore finished; //初始0，表示一次理发结束
Semaphore ready;
//初始0，表示客人准备就绪
Customer:
While(1){
wait(max); wait(chair);
wait(barber); signal(chair); signal(ready);
… barbered …
wait(finished); signal(max);
}
Barber:
While(1){
wait(ready);
… barbering…
signal(finished);
signal(barber);
}
Operating System Concepts
7.79
Silberschatz, Galvin and Gagne 2002
Lab
实验1(a)：进程间通讯
要求：
1.写一个程序，通过fork创建一个子进程。父进程与子进程间通过共享存储器（
shared memory）进行通讯：
2.父进程读取一个指定的文本文件，将文件中的每一行读入到共享存储器中，然后等
待子进程结束。
3.子进程判断由父进程读入的存放在共享存储器中的各行是否是回文（指顺读和倒读
都一样的字串，忽略空格），并将各行内容及判断结果(yes or no)输出到屏幕上。
提示：
a.父进程在创建子进程前通过系统调用shmget先向内核申请创建一个共享存储段，申
请时给它一个key值（整数）；
b.子进程利用与父进程相同的key值去申请使用该共享存储段；
请通过Linux的man工具查询shmget, shmat,shmdt的用法。
Key_t key; int shmid;
Key = 5678;
申请创建：shmid = shmget(key,100,IPC_CREAT|0666);
申请使用：semid = shmget(key,100,0666);
Operating System Concepts
7.80
Silberschatz, Galvin and Gagne 2002
Lab
实验1(b)：进程间通讯
要求：
1.在实验1(a)的基础上，实现生产者/消费者问题，要求不是父子进程而是两个独立
的进程进行通讯（两个独立的进程单独运行）；
2.将共享存储器作为一个环形缓冲区来管理，生产者进程往里面放消息（一个消息
是一行字符串），消费者进程一次从里面读取一个消息，再如1(a)一样判断其是否
为一回文，并输出；
3. 因为两进程可能同时访问该共享存储段，因而需要通过信号量进行同步。
注：信号量的使用：两个进程通过相同的key值向OS申请，一个进程（生产者）申
请创建，另一个进程（消费者）申请使用。方法与共享存储器的使用类似。
请通过Linux的man工具查询semget, semop的用法。
Key_t key; int semid;
Key = 5678;
申请创建：semid = semget(key,1,IPC_CREAT|0666);
申请使用：semid = semget(key,1,0666);
Operating System Concepts
7.81
Silberschatz, Galvin and Gagne 2002