1. 第三章 进程同步与通信 3.1 进程同步 3.2 经典进程的同步问题 3.3 管程机制 3.4 进程通信

2. 3.1 进 程 同 步 ( 重点 )

6. 2. 临界资源 (Critical Resouce) 临界资源 : 在一段时间内只允许一个进程访问 的资源。诸进程间应采取 互斥方式 ，实现对资源的共享。 共享变量，打印机 等均属于此类资源 。

7. 共享变量的修改冲突 共享变量 X

8. 生产者—消费者问题 (Producer-Consumer) 有一个 生产者进程和一个消费者进程。 他们 共享一个缓冲区。 生产者进程每生产一件物品就要存入缓冲区，但缓冲区每次只能存放一件物品，只有消费者取走物品，才能放入第二件物品。 消费者进程不断从缓冲区中取走产品去消费，缓冲区中有物品他就可以去取，每取走一件物品后必须等生产者再放入物品后才可以去取。。 生产者进程与消费者进程是以 异步方式 进行的，但它们之间必须 保持同步 ； 即不允许消费者进程到一个空缓冲区去取产品，也不允许生产者进程向一个装满产品的缓冲区中投放产品 。

10. 生产者—消费者问题 (Producer-Consumer) 有一群 生产者进程 在生产产品，并将产品提供给消费者进程去消费， 为使 生产者进程 和 消费者进程 能 并发执行 ，在他们之间设置了一个具有 n 个缓冲区的 缓冲池 ，生产者进程将他所生产的产品放入一个缓冲区中； 消费者进程可从一个缓冲区中取走产品去消费。 生产者进程与消费者进程是以异步方式进行的，但它们之间必须保持同步； 即不允许消费者进程到一个空缓冲区去取产品，也不允许生产者进程向一个装满产品的缓冲区中投放产品 。

11. in out

12. 1 、用一个 数组 来 表示 上述的具有 n 个缓冲区的 缓冲 池 ，用 0,1,…,n-1 表示。 2 、用 输入指针 in 来指示下一个可投放产品的缓冲，每当生产者投放一个产品，输入指针 加 1 ； 3 、用 输出指针 out 来指示下一个可从中获取产品的缓冲区，每当消费者进程取走一个产品后，输出指针 加 1 。 这里的缓冲池是组织成循环缓冲的，故应 把输入指针加 1 表示成 in:=(in+1) mod n ; 把输出指针加 1 表示成 out:=(out+1) mod n . 当 (in+1)=out 时表示缓冲池 满 ； in=out 时表示缓冲池 空 。 ？

13. 还引入一个整型变量 counter ，初值为 0 ， 生产者进程向缓冲池 投放一个产品 后， counter 加 1 ； 消费者进程从中 取走一个产品 时，使 counter 减 1 ； 生产者和消费者共享下面的变量： var n:integer; type item=…; var buffer:array[0,1,…,n-1] of item; in , out :0,1,…,n-1; counter :0,1,…,n-1 ;

14. producer: repeat … produce an item in nextp; … while counter=n do no_op; buffer[in]=nextp; in:=(in+1) mod n; counter=counter+1 ; until false; consumer: repeat while counter=0 do no_op; nextc:=buffer[out]; out:=(out+1) mod n; counter=counter-1 ; consume the item in nextc; until false; 表示目前缓冲区产品已放满 刚生产出来的产品 刚消费的产品

15. 虽然上面的生产者程序和消费者程序，在分别看时都是正确的，而且两者在顺序执行时其结果也会是正确的，但若 并发执行 时，就 会出现差错 ，问题就在于这两个进程共享变量 counter 。生产者对它做加 1 操作，消费者对它做减 1 操作，这两个操作在用机器语言实现时， 常可用下面的形式描述： register1 ∶ = counter ; register2∶= counter ; register1∶=register1+1; register2∶=register2-1; counter ∶ =register1; counter ∶=register2; 假设： counter 的当前值是 5 。无论是先执行生产者的语句还是先执行消费者的语句， counter 都为 5

16. 但是，如果按下述顺序执行： register1 ∶ = counter ; (register1 = 5) register1 ∶ =register1 + 1; (register1 = 6) register2 ∶ = counter ; (register2 = 5) register2 ∶ =register2 - 1; (register2 = 4) counter ∶ =register1; (counter = 6) counter ∶ =register2; (counter = 4) 最后 counter 的值为 4, 并且结果不可预见 . 解决问题的关键是 , 把 counter 作为临界资源来处理 , 即令生产者和消费者进程互斥访问变量 counter. 执行过程相当于生产一点拿一点 , 而不是消费完整的产品

18. repeat Entry section Critical section; Remainder section Until false; exit section 进入区， P 、 V 操作 临界区 退出区， P 、 V 操作 剩余区 P ： wait(S) ,P(S) 可理解为 关锁 V ： signal(S),V(S) 可理解为 开锁

19. 图 3.12 资源互斥使用例

27. 信号量 (semaphore) 前面的 互斥 算法都存在问题，它们是 平等进程 间的一种 协商 机制，需要一个地位高于进程的 管理者 来解决公有资源的使用问题。 OS 可从进程管理者的角度来处理 互斥 的问题， 信号量 就是 OS 提供的管理公有资源的有效手段。 信号量 代表 可用资源实体的数量 。

28. 3. 1.2 信号量机制 1. 整型信号量  最初由 Dijkstra 把整型信号量定义为一个 整型量 ， 除 初始化 外 ，仅能通过两个标准的原子操作 (Atomic Operation) wait(S) 和 signal(S) 来访问。这两个操作一直被分别称为 P 、 V 操作 。 wait 和 signal 操作可描述为： wait(S): while S≤0 do no-op S∶=S-1 ; signal(S): S ∶=S+1;  信号量 P 操作，又称关锁 V 操作，又称开锁 占用资源，所以减一 释放资源，所以加一 S 代表资源个数 不放弃处理机

29. 2. 记录型信号量  在整型信号量机制中的 wait 操作，只要是信号量 S≤0 ， 就会不断地测试。 记录型信号量机制，则是一种 不存在“忙等” 现象的进程 同步机制 。 记录型信号量是由于它采用了记录型的数据结构而得名的。它所包含的上述两个数据项可描述为： S 代表资源个数

30. s:=s+1 Wait(s): Signal(s): Block 自我阻塞， 放弃处理机 S  0 Wake Up Y N S  0? S=S-1 y n S  0? S=S-1 y n

35. type semaphore=record value:integer; L:list of process; end 相应地， wait(S) 和 signal(S) 操作可描述为： procedure wait(S)  var S: semaphore; begin S.value∶ =S.value-1 ; if S.value ＜ 0 then block (S,L) end procedure signal(S) var S: semaphore; begin S.value∶ =S.value+1 ; if S.value≤0 then wakeup (S,L); end 系统中某类资源的数目 每次 wait 操作，意味着进程请求一个单位的该类资源－ 1 资源已分配完毕，因此进程应调用 block 原语，进行自我阻塞 信号量链表中，仍有等待该资源的进程被阻塞，应将进程唤醒 S 代表资源个数

36. 如果 S.value 的初值为 1 ，表示只允许一个进程访问临界资源，此时的信号量转化为 互斥信号量 。

37. 3. AND 型信号量 在两个进程中都要包含两个对 Dmutex 和 Emutex 的操作， 即 process A: process B: wait ( Dmutex ); wait ( Emutex ); wait ( Emutex ); wait ( Dmutex ); 若进程 A 和 B 按下述次序交替执行 wait 操作： process A: wait(Dmutex); 于是 Dmutex=0 process B: wait(Emutex); 于是 Emutex=0 process A: wait(Emutex); 于是 Emutex=-1 A 阻塞 process B: wait(Dmutex); 于是 Dmutex=-1 B 阻塞 2 个共享数据，初值为 1 P 操作，－ 1 ， S<0 阻塞 谁也不释放，死锁状态

38. AND 同步机制的基本思想 是： 将进程在整个运行过程中需要的所有资源，一次性全部地分配给进程，待进程使用完后再一起释放。 只要尚有一个资源未能分配给进程，其它所有可能为之分配的资源，也不分配给他。 对若干个临界资源的分配，采取原子操作方式： 要么全部分配到进程，要么一个也不分配。 由死锁理论可知，这样就可避免上述死锁情况的发生。 为此，在 wait 操作中，增加了一个“ AND” 条件，故称为 AND 同步，或称为同时 wait 操作， 即 Swait(Simultaneous wait) 定义如下：

39. Swait (S 1 , S 2 , …, S n ) if S i ≥1 and … and S n ≥1 then for i∶ =1 to n do S i ∶= S i -1 ; endfor else place the process in the waiting queue associated with the first S i found with S i ＜ 1, and set the program count of this process to the beginning of Swait operation endif Ssignal (S1, S2, …, Sn) for i∶ =1 to n do S i = S i +1 ; Remove all the process waiting in the queue associated with S i into the ready queue. endfor; N 类资源 每类资源只申请 1 个

40. 在 记录型信号量 机制中， wait(s) 或 signal(s) 操作仅能对信号量施以 增 1 或减 1 的操作，即每次只能获得或释放一个单位的临界资源。 当一次需 N 个某类临界资源时，便需要进行 N 次 wait(s) 操作，显然这是低效的。 此外，在有些情况下，当 资源数量低于某一下限值时，便不予分配。 因而，在每次分配之前，都必须测试该资源的数量是否大于测试值 t 。 基于上述两点可以对 AND 信号量机制进行扩充，形成一般化的“信号量集”机制。 4. 信号量集 S 代表资源个数

41. Swait ( S 1 , t 1 , d 1 , …, S n , t n , d n ) if S i ≥t 1 and … and S n ≥t n then for i∶=1 to n do S i ∶= S i -d i ; endfor else Place the executing process in the waiting queue of the first S i with S i ＜ t i and set its program counter to the beginning of the Swait Operation.  endif  signal (S 1 , d 1 , …, S n , d n ) for i∶=1 to n do S i ∶= S i +d i ; Remove all the process waiting in the queue associated with S i into the ready queue endfor; S 为信号量 t 为下限值 d 为需求值

42. 一般“信号量集”的几种特殊情况： (1) Swait(S, d, d ) 。 此时在信号量集中只有一个信号量 S ， 但允许它每次申请 d 个资源，当现有资源数少于 d 时，不予分配。 (2) Swait(S, 1, 1) 。 此时的信号量集已蜕化为一般的 记录型信号量 (S ＞ 1 时 ) 或 互斥信号量 (S=1 时 ) 。 (3) Swait(S, 1, 0) 。这是一种很特殊且很有用的信号量操作。当 S≥1 时，允许多个进程进入某特定区；当 S 变为 0 后，将阻止任何进程进入特定区。换言之， 它相当于一个可控开关。 S 代表资源个数

43. Swait(S1, S2, …, Sn) //P 原语 ； { while (TRUE) { if (S1 >=1 && S2 >= 1 && … && Sn >= 1) { // 满足资源要求时的处理； for (i = 1; i <= n; ++i) --Si; // 注：与 wait 的处理不同，这里是在确信可满足 // 资源要求时，才进行减 1 操作； break; } else { // 某些资源不够时的处理； 调用进程进入第一个小于 1 信号量的等待队列 Sj.queue ; 阻塞调用进程 ; } } } AND 信号量

44. Ssignal(S1, S2, …, Sn) { for (i = 1; i <= n; ++i) { ++Si; // 释放占用的资源； for (each process P waiting in Si.queue) // 检查每种资源的等待队列的所有进程； { 从等待队列 Si.queue 中取出进程 P; if ( 判断进程 P 是否通过 Swait 中的测试 ) // 注：与 signal 不同，这里要进行重新判断 ； { // 通过检查（资源够用）时的处理； 进程 P 进入就绪队列 ; } else { // 未通过检查（资源不够用）时的处理； 进程 P 进入某等待队列； } } } }

47. 利用信号量实现 进程互斥 的进程可描述如下： Var mutex :semaphore∶ =1; begin parbegin process 1 : begin repeat wait ( mutex ); critical section  signal ( mutex ); remainder section  until false; end  process 2 : begin repeat wait ( mutex ); critical section  signal ( mutex ); remainder section  until false; end parend 只能有一个进程进入执行

50. 图 2-10 前趋图举例 a b c d g f e

51. Var a,b,c,d,e,f,g ; semaphore∶= 0,0,0,0,0,0,0;  begin parbegin begin S 1 ; signal(a); signal(b); end; begin wait(a); S 2 ; signal(c); signal(d); end; begin wait(b); S 3 ; signal(e); end; begin wait(c); S 4 ; signal(f); end; begin wait(d); S 5 ; signal(g); end; begin wait(e); wait(f); wait(g); S 6 ; end; parend end

52. 3.2 经典进程的同步问题 进程互斥 ：指的是一个进程正在使用某个系统资源，另外一个想用该资源的进程就必须等待，而不能同时使用。 进程同步 ：指的是两个或多个进程为了合作完成同一个任务，在执行速度或某个确定的时序点上必须相互协调，即一个进程的执行必须依赖另一个进程。 多个进程之间通信使用阻塞和唤醒消息进行通信。 往往一个实际问题多个进程既有同步也有互斥 。

53. 3.2 经典进程的同步问题 3.2.1 生产者—消费者问题 用 PV 操作实现简单生产者和消费者的同步： 设两个信号量 SP 和 SG SP 表示 是否允许把物品放入缓冲区 ， 1 允许， 0 不许，初值设为 1 SG 表 缓冲区是否存有物品 ，初值为 0 ，表示还没有物品 生产一种产品 产品送入缓冲区 P( SP ) V( SG ) V( SP ) P( SG ) 从缓冲区取走一个产品 消耗该产品

54. SP, SG:semaphore∶=1, 0; buffer: integer ; parbegin  proceducer:begin  L1 ： producer an product;  P( SP ); buffer ∶= product; V( SG ); go to L1; end ； proceducer:begin  L2 ： P( SG ); take a product from buffer ; V( SP ); consum an product;  go to L2; end ； parend ； 判断是否允许把物品放入缓冲区 通知消费者，缓冲区有东西了 通知生产者者，可以向缓冲区放东西了 判断缓冲区是否有物品

55. 1. 利用 记录型信号量 解决生产者—消费者问题 信号量有： Mutex ：实现读和取诸进程对缓冲池的互斥访问 ，初值为 1 Empty ： 表示缓冲池 中空缓冲区的数量 ，初值为 n ，表全空 Full ： 表示缓冲池中 产品的数量 ，初值为 0 ，没产品 又假定这些生产者和消费者相互等效，只要缓冲池未满，生产者便可将消息送入缓冲池；只要缓冲池未空，消费者便可从缓冲池中取走一个消息。 对生产者—消费者问题可描述如下 ：

56. Var mutex , empty , full :semaphore∶= 1, n, 0 ; buffer :array ［ 0, …, n-1 ］ of item; in, out : integer∶=0, 0; begin parbegin proceducer:begin  repeat … producer an item nextp; … wait( empty ); wait( mutex ); buffer(in)∶=nextp; in∶=(in+1) mod n;  signal( mutex ); signal( full ); until false;  end 就是一把锁，防其它生产者进程影响 不允许多个进程同时用一个输入指针，每一时刻只允许一个生产者进程使用该指针，否则会冲突 判断是否允许向缓冲区放东西，初值允许放 n 个 放入了产品，加 1 操作，初值为 0 ，表示没有产品 保证存和取互斥 P(mutex) 锁的作用 ?

57. consumer:begin repeat wait( full ); wait( mutex ); nextc∶ =buffer(out); out∶ =(out+1) mod n;  signal( mutex ); signal( empty ); consumer the item in nextc; until false ; end parend end 判断缓冲区是否有产品，初值为 0 消费了一个产品，空出一个空缓冲区，所以个数加 1 ？ 不允许多个进程同时用一个输出指针，每一时刻只允许一个消费者进程使用该指针，否则会冲突 类似于只有 1 台自行车，多个人

58. 首先 ，在每个程序中用于实现互斥的 wait(mutex) 和 signal(mutex) 必须成对地出现 ； 其次 ，对资源信号量 empty 和 full 的 wait 和 signal 操作，同样需要成对地出现，但它们分别处于不同的程序中。 例如 ， wait(empty) 在 计算进程 中，而 signal(empty) 则在 打印进程 中，计算进程若因执行 wait(empty) 而阻塞， 则以后将由打印进程将它唤醒； 最后 ，在每个程序中的多个 wait 操作 顺序 不能颠倒。应先执行对 资源信号量 的 wait 操作，然后再执行对 互斥信号量 的 wait 操作， 否则可能引起进程死锁 。  如果这 2 个顺序颠倒呢？ wait( full ); wait( mutex ); 注意：

59. wait( mutex ); wait( empty ); buffer( in )∶=nextp; in ∶=( in +1) mod n; signal( full ); signal( mutex ); wait( mutex ); wait( full );  nextc∶ =buffer(out); out∶ =(out+1) mod n; signal( empty ); signal( mutex );

60. 2. 利用 AND 信号量解决生产者—消费者问题 var mutex, empty, full:semaphore∶ = 1, n, 0 ; buffer:array ［ 0, …, n-1 ］ of item; in out:integer∶ =0, 0; begin parbegin producer:begin repeat … produce an item in nextp; … Swait(empty, mutex); // P (empty, mutex); buffer(in)∶ =nextp; in∶ =(in+1)mod n; Ssignal(mutex, full); // V (mutex, full );  until false; end

61. consumer:begin repeat Swait(full, mutex); nextc∶ =buffer(out); out∶ =(out+1) mod n; Ssignal(mutex, empty); consumer the item in nextc; until false; end parend end

62. 例 1 用信号量实现司机和售票员的同步。 设 S1 为司机的私用信号量， 0 表不许开车， 1 允许开车 ，初值为 0 S2 为售票员的私用信号量， 0 表不许开门， 1 允许开门 ，初值为 0 由于初始状态是汽车行车和售票员售票。所以初值都为 0 则司机和售票员的同步过程描述如下：

65. Begain S, SP, SO : semaphore S:=1; SP:=0; SO:=0; Cobegain process father begain L 1:have an apple; P(S); put an apple; V(SP); go to L 1 end;

66. process mother begain L 2:have an orange; P(S); put an orange; V(SO); go to L 2 end;

67. process son begain L3: P(SO); get an orange; V(S); eat an orange; go to L 3 end; process daught begain L4: P(SP); get an apple; V(S); eat an apple; go to L4 end ; coend ; end ;

69. 1. 利用记录型信号量解决哲学家进餐问题 经分析可知，放在桌子上的筷子是 临界资源 ，在一段时间内只允许一位哲学家使用。为了实现对筷子的 互斥 使用，可以用 一个信号量表示一只筷子 ，由这五个信号量构成信号量数组。其描述如下：  Var chopstick: array ［ 0, …, 4 ］ of semaphore;

70. 所有信号量均被初始化为 1 ， 第 i 位哲学家的活动可描述为： repeat wait(chopstick ［ i ］ ); wait(chopstick ［ (i+1) mod 5 ］ ); … eat; … signal(chopstick ［ i ］ ); signal(chopstick ［ (i+1) mod 5 ］ );  … think; until false; 拿起左边的筷子 拿起右边的筷子 放下左边的筷子 放下右边的筷子

72. 可采取以下几种解决方法： (1) 至多只允许有四位哲学家同时去拿左边的筷子，最终能保证至少有一位哲学家能够进餐，并在用毕时能释放出他用过的两只筷子，从而使更多的哲学家能够进餐。 (2) 仅当哲学家的左、右两只筷子均可用时，才允许他拿起筷子进餐。 (3) 规定奇数号哲学家先拿他左边的筷子，然后再去拿右边的筷子；而偶数号哲学家则相反。按此规定，将是 1 、 2 号哲学家竞争 1 号筷子； 3 、 4 号哲学家竞争 3 号筷子。即五位哲学家都先竞争奇数号筷子，获得后，再去竞争偶数号筷子，最后总会有一位哲学家能获得两只筷子而进餐。

73. 2. 利用 AND 信号量机制解决哲学家进餐问题  在哲学家进餐问题中，要求每个哲学家先获得两个临界资源 ( 筷子 ) 后方能进餐，这在本质上就是前面所介绍的 AND 同步问题，故用 AND 信号量机制可获得最简洁的解法。 Var chopstick array ［ 0, …, 4 ］ of semaphore∶ =( 1,1,1,1,1 ); processi repeat think; P (chopstick ［ (i+1) mod 5 ］ , chopstick ［ i ］ ); eat; V (chopstick ［ (i+1) mod 5 ］ , chopstick ［ i ］ ); until false;  只有能同时拿起两边的筷子，才允许吃，否则一只筷子也不许拿

75. 3.2.3 读者 - 写者问题 1. 利用记录型信号量解决读者 - 写者问题  为实现 Reader 与 Writer 进程间在读或写时的互斥而设置了一个互斥信号量 Wmutex 。另外，再设置一个整型变量 Readcount 表示正在读的进程数目。 由于只要有一个 Reader 进程在读，便不允许 Writer 进程去写。 因此，仅当 Readcount=0, 表示尚无 Reader 进程在读时， Reader 进程才需要执行 Wait(Wmutex) 操作。若 wait(Wmutex) 操作成功， Reader 进程便可去读，相应地，做 Readcount+1 操作。同理，仅当 Reader 进程在执行了 Readcount 减 1 操作后其值为 0 时，才须执行 signal(Wmutex) 操作，以便让 Writer 进程写。又因为 Readcount 是一个可被多个 Reader 进程访问的 临界资源 ，因此，应该为它设置一个互斥信号量 rmutex 。

77. 读者 - 写者问题可描述如下：  Var rmutex , wmutex :semaphore∶ =1,1; Readcoun t :integer∶ =0; begin parbegin Reader:begin repeat P(rmutex);  if readcount=0 then P( wmutex ); Readcount∶ =Readcount+1; V(rmutex);  … perform read operation; …

78. P(rmutex); readcount∶ =readcount-1; if readcount=0 then V(wmutex); V(rmutex); until false; end writer:begin repeat P(wmutex); perform write operation; V(wmutex); until false; end parend end

80. 2. 利用信号量集机制解决读者 - 写者问题 Var RN integer; L, mx:semaphore∶ =RN,1; begin parbegin reader:begin repeat Swait(L,1,1); Swait(mx,1,0); … perform read operation; …

81. Ssignal(L,1); until false; end writer:begin repeat Swait(mx,1,1; L,RN,0); perform write operation; Ssignal(mx,1); until false; end parend end

82. 3.3 管 程 (monitor) 用 信号量 可实现 进程间的同步 ，但由于信号量的控制分布在整个程序中，其正确性分析很困难。 管程是管理 进程间同步 的机制，它保证进程互斥地访问共享变量，并方便地阻塞和唤醒进程 。管程可以函数库的形式实现。相比之下，管程比信号量好控制。

90. 条件变量 管程中对每个条件变量，都须予以说明，其形式为： Var x, y:condition 。该变量应置于 wait 和 signal 之前，即可表示为 X.wait 和 X.signal 。 例如，由于共享数据被占用而使调用进程等待，该条件变量的形式为： nonbusy :condition 。此时， wait 原语应改为 nonbusy .wait ，相应地， signal 应改为 nonbusy .signal 。 应当指出 ， X.signal 操作的作用，是 重新启动一个被阻塞的进程，但如果没有被阻塞的进程，则 X.signal 操作不产生任何后果 。这与信号量机制中的 signal 操作不同。因为，后者总是要执行 s∶ =s+1 操作，因而总会改变信号量的状态 。

91. 如果有进程 Q 处于阻塞状态， 当进程 P 执行了 X.signal 操作后，怎样决定由哪个进行执行，哪个等待，可采用下述两种方式之一进行处理： (1) P 等待，直至 Q 离开管程或等待另一条件。 (2) Q 等待，直至 P 离开管程或等待另一条件。 采用哪种处理方式， 当然是各执一词。 但是 Hansan 却采用了第一种处理方式。

92. 7. 管程的格式 TYPE monitor_name = MONITOR ; 共享变量说明 define 本管程内所定义、本管程外可调用的过程（函数）名字表 use 本管程外所定义、本管程内将调用的过程（函数）名字表 PROCEDURE 过程名（形参表）； 过程局部变量说明； BEGIN 语句序列； END; ......

93. FUNCTION 函数名（形参表）：值类型； 函数局部变量说明； BEGIN 语句序列； END; ...... BEGIN 共享变量初始化语句序列 ； END;

94. 图 2-11 管程的示意图 管程的语法如下： type monitor-name=monitor variable declarations procedure entry P1(…); begin … end; procedure entry P2(…); begin … end;  … procedure entry Pn(…); begin … end; begin initialization code; end

97. 3.3.2 利用管程解决生产者 - 消费者问题 在利用管程方法来解决生产者 - 消费者问题时， 首先便是为它们建立一个 管程 ，并命名为 Proclucer-Consumer , 或简称为 PC 。其中包括两个过程： 

98. (1) put(item) 过程。 生产者利用该过程将自己生产的产品投放到缓冲池中， 并用整型变量 count 来表示在缓冲池中已有的产品数目，当 count≥n 时，表示缓冲池已满，生产者须等待。 (2) get(item) 过程。消费者利用该过程从缓冲池中取出一个产品，当 count≤0 时，表示缓冲池中已无可取用的产品， 消费者应等待。

99. type producer-consumer = monitor  Var in,out,count:integer; buffer:array ［ 0,…,n-1 ］ of item; notfull , notempty : condition ; procedure entry put(item) begin if count≥n then notfull . wait ; buffer(in)∶ =nextp; in∶ =(in+1) mod n; count∶ =count+1; if notempty . queue then notempty . signal ; end PC 管程可描述如下：

100. procedure entry get(item) begin if count≤0 then notempty.wait ; nextc∶ =buffer(out); out∶ =(out+1) mod n; count∶ =count-1; if notfull.quene then notfull.signal ; end begin in∶ =out∶ =0; count∶ =0 end

101. 在利用管程解决 生产者 - 消费者 问题时， 其中的生产者和消费者可描述为： producer:begin repeat produce an item in nextp; PC.put(item);  until false; end consumer:begin repeat PC.get(item);  consume the item in nextc; until false; end

102. 3.4 进 程 通 信 写份大作业： 操作系统中消息机制 的研究 。 同步通信—— 在多任务系统中，存在资源的共享与进程的合作，为了安全的使用资源，必须对多个相关任务在执行的次序上进行协调，所用的方法就是提供 Event Flag( 任务间传递 Flag 信息 ) ， Semaphore( 对系统资源进行排他访问 ) ， MailBox( 任务之间进行信息通信 ) 机制。 一个进程直接或通过某一机构发一条消息给另一进程，且据此来控制其它进程，我们将进程之间的这种信息交流称为 进程通信 。