chapter 7: process synchronization

Silberschatz, Galvin and Gagne 20027.1Operating System Concepts

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


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 producer-consumer

code by adding a variable counter, initialized to 0 and incremented each time a new item is added to the buffer


Bounded-Buffer

Shared data

#define BUFFER_SIZE 10

typedef struct {

. . .

} item;

item buffer[BUFFER_SIZE];

int in = 0;

int out = 0;

int counter = 0;


Bounded-Buffer

Producer process

item nextProduced;

while (1) {

while (counter == BUFFER_SIZE)

; /* do nothing */

buffer[in] = nextProduced;

in = (in + 1) % BUFFER_SIZE;

counter++;

}


Bounded-Buffer

Consumer process

item nextConsumed;

while (1) {while (counter == 0)

; /* do nothing */nextConsumed = buffer[out];out = (out + 1) % BUFFER_SIZE;counter--;

}


Bounded Buffer

The statements

counter++;counter--;

must be performed atomically.( 原子地 )

Atomic operation means an operation that completes in its entirety without interruption. ( 原子操作 )


Bounded Buffer

The statement “count++” may be implemented in machine language as:

register1 = counter

register1 = register1 + 1counter = register1

The statement “count—” may be implemented as:

register2 = counterregister2 = register2 – 1counter = register2


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.


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.


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)

Another example


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.


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.


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.


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.

Methods to solve the CS Problem


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


Algorithm 1

Shared variables:

int turn;initially turn = 0

turn = i Pi can enter its critical section Process Pi

do {while (turn != i) ;

critical sectionturn = j;

reminder section} while (1);

Satisfies mutual exclusion, but not progress( 必须交替进入)


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 sectionflag [i] = false;

remainder section} while (1);

Satisfies mutual exclusion, but not progress requirement.( 互相谦让 )


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.


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.

Proof of Algorithm 3


Bakery’s Algorithm

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...

Critical section for n processes


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 databoolean choosing[n];int number[n];

Data structures are initialized to false and 0 respectively


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 sectionnumber[i] = 0;

remainder section} while (1);


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;

}


Mutual Exclusion with Test-and-Set

Shared data: boolean lock = false;

Process Pi

do {while (TestAndSet(lock)) ;

critical sectionlock = false;

remainder section}


Synchronization Hardware

Swap instruction: Atomically swap two variables.

void Swap(boolean &a, boolean &b) {

boolean temp = a;

a = b;

b = temp;

}


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

}


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

Hardware solution features


Shared data (initialized to false): boolean lock;

boolean waiting[n]; Process Pi

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

}

Mutual Exclusion with TestAndSet-- Bounded-waiting


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++;


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);


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.


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);}


Semaphore as a General Synchronization Tool

Execute B in Pj only after A executed in Pi

Use semaphore flag initialized to 0 Code:

Pi Pj

A wait(flag)

signal(flag) B


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.


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.


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 }

Binary semaphores(Mutex)


Implementing S using Binary Semaphores

Data structures: binary-semaphore S1, S2; int C:

Initialization: S1 = 1 S2 = 0 C = initial value of semaphore S


Implementing S

wait operationwait(S1);C--;if (C < 0) {

signal(S1);wait(S2);

}signal(S1);

signal operation

wait(S1);C ++;if (C <= 0)

signal(S2); else

signal(S1);


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


Bounded-Buffer Problem

Shared data

semaphore full, empty, mutex;

Initially:

full = 0, empty = n, mutex = 1


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);

do { wait(full)wait(mutex);

…remove an item from buffer to nextc

…signal(mutex);signal(empty);

…consume the item in nextc

…} while (1);


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);


Readers-Writers Problem

Problem description: 读者只能读取共享数据，写者可以读写共享数据。写者只有一人，读者可以有多人。读者和写者不能共存

Shared data

semaphore mutex // 互斥访问 readcount semaphore wrt; // 读者和写者不能共存

Initially

mutex = 1, wrt = 1, readcount = 0 // 读者人数


Readers-Writers Problem Writer Process

wait(wrt); // 申请进入 …

writing is performed …

signal(wrt); // 离开


Reader Process writer: wait(wrt); // 申请进入

…writing is performed …signal(wrt); // 离开

reader:wait(mutex); // 申请访问 readcountreadcount++;if (readcount == 1) // 如果是第一个读者，禁止写者进入wait(wrt);signal(mutex); // 释放访问 readcount 的锁 …reading is performed …wait(mutex); // 申请访问 readcountreadcount--;if (readcount == 0) // 如果没有读者了，应该允许写者进

入signal(wrt); signal(mutex): // 释放访问 readcount 的锁



Shared data

semaphore chopstick[5]:=1, count := 4



Philosopher i:do {

wait(count);wait(chopstick[i]) //want to pick up left chopstickwait(chopstick[(i+1) % 5]) //the right one

…eat …

signal(chopstick[i]); //release leftsignal(chopstick[(i+1) % 5]);//release rightsignal(count);

…think …

} while (1);


有 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); } }

例题


思考题

有一个仓库存放两种零件 A 和 B ，最大库容量各为m 个。有一车间不断地取 A 和 B 进行装配，每次各取一个。有两种供应商分别不断地供应 A 和 B 。为保证齐套和合理库存，当某种零件的数量比另一种的数量超过 n(n<m) 个时，暂停对数量大的零件进货，集中补充数量少的零件。试用信号量正确地实现之。


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)

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

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)

Unix Semaphores


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.


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.


Example – Bounded Buffer

Shared data:

struct buffer {

int pool[n];

int count, in, out;

}


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++;

}


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--;

}


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.


Implementation

Keep track of the number of processes waiting on first-delay and second-delay, with first-count 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.


Monitors( 管程 ) High-level synchronization construct that allows the safe sharing

of an abstract data type among concurrent processes.monitor monitor-name{

shared variable declarationsprocedure body P1 (…) {

. . .}procedure body P2 (…) {

. . .} procedure body Pn (…) {

. . .} {

initialization code}

}


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.


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()

Monitor


Schematic View of a Monitor


Monitor With Condition Variables


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;

}}


void pickup(int i) {state[i] = hungry;test[i];if (state[i] != eating)

self[i].wait();}void putdown(int i) {

state[i] = thinking;// test left and right neighborstest((i+4) % 5);test((i+1) % 5);

} void test(int i) {

if ( (state[(i + 4) % 5] != eating) && (state[i] == hungry) && (state[(i + 1) % 5] != eating)) {

state[i] = eating;self[i].signal();

}}

Philosopher i: … dp.pickup(i); … eat … dp.putdown(i);

No deadlockMay cause starvation


Monitor Implementation Using Semaphores

Variables semaphore mutex; // (initially = 1)semaphore next; // (initially = 0)int next-count = 0; // 让位的进程数

Each external procedure F will be replaced bywait(mutex); // 进入 monitor … body of F; …if (next-count > 0) // 离开前看有没有让位进程，如有

，激活它们中的一个，不让其他进程进入，否则，释放 mutex, 让其他一个进程进入

signal(next)else

signal(mutex);

Mutual exclusion within a monitor is ensured.


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--;



The operation x.signal can be implemented as:

if (x-count > 0) { next-count++; // 自己变为让位进程 signal(x-sem); // 释放等待队列中的一个进程 wait(next); // 自己进入让位进程队列 next-count--; // 从让位进程队列出来，继续执行} // 如果没有等待该条件的进程，什么也不做



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.


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.


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.


Spin lock( 旋转锁 ) on multiprocessor systems.× 利用 busy waiting 而非 blocking 来阻止进程前进；

× CPU 不会去做其他事情，虽然浪费了部分 CPU 时间，但省去了进程切换；

× 适合短代码的加锁

wait(S): S--; while S<0 do{};

signal(S): S++; 与 spin lock 相对应的就是 suspend lock （挂起锁），即一

般的锁，会挂起（阻塞）进程的执行

Spin lock


7.3if 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 无法进入

Exercises


7.4Dekker 算法

while(1) {

flag[ i ] = true;

while (flag[j]) {

if (turn==j) {

flag[ i ] = false;

while ( turn == j );

flag[ i ] = true;

}

}

CS

turn = j;

flag[ i ] = false;

RS

}

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)

Pi 离开 CS 后，置 turn=j,flag[ i ]=false,这时 Pj 可以进入，如果 Pj 没有进入， Pi又执行了 falg[ i ]=true, 则由于 turn==j ，所以 Pi 无法进入，而 Pj 可以进入

Exercises


7.5Eisenberg and McGuire’s algorithm

While(1) {

while(1) {

flag[i] = want_in;

j = turn;

while (j !=i) {

if (flag[j]!=idle) j = turn

else j = (j+1)%n;

}

flag[i] =in_cs; j = 0;

while ((j<n)&&(j ==i || flag[j]!=in_cs)

j ++ ;

if ((j>=n)&&(turn==i||flag[turn]==idle))

break;

}

turn = i ; CS

j = (turn+1)%n;

while(flag[j]==idle) j=(j+1)%n;

turn=j; flag[i]=idle; RS

}

1. 互斥 (mutual exclusion)

A) 两个进程 Px 和 Py 不可能同时进入 CS ：

turn==x 和 turn==y 不会同时满足，故 Px 和Py 的两个 if 条件不会都满足

B) 一个进程 ( 如 Px) 先进入 CS, 则turn==x ， flag[turn]==in_cs, 则其他进程无法进入

2. 前进 (progress ）

A)Px 申请进入，其他进程不想进入，则其他进程 flag 均为 idle, 则 Px 的 j>=n 成立， if 条件成立，跳出 while ，进入 CS

B) 若干进程想进入，如 Pturn 也想进入，则Pturn 优先进入；否则，编号在 turn 后的最小号的想进入的进程进入 CS

3. 有限等待 (bounded waiting)

Pi 离开 CS 时，置 turn 为想进入的进程中大于 turn 的最小欲进入之进程号，该进程就进入。

进程 Pk 不会饿死，最多等待（ k-turn) 个进程的 CS 执行

Exercises


7.9 抽烟问题Semaphore smoker[3]; // 初始 0 ，三个抽烟者Semaphore material[3]; // 初始 0 ，三种原料Semaphore agent; // 初始 1 ，供应商Int turn; // 初始 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);}

Exercises


7.11Monitor bounded_buffer{ item pool[n]; int count, in, out; 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;}}

Producer process:While(1) { produce an item; bounded_buffer.put_item();}

Consumer process:While (1) { bounded_buffer.get_item(); consume the item;}

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);}

Exercises


要求：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);

实验 1(a) ：进程间通讯Lab


要求：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);

实验 1(b) ：进程间通讯

Lab

chapter 7: process synchronization

Documents