第四章作业参考答案.docx
《第四章作业参考答案.docx》由会员分享，可在线阅读，更多相关《第四章作业参考答案.docx（22页珍藏版）》请在冰豆网上搜索。
第四章作业参考答案
2 答：
多道程序在单 CPU 上并发运行和多道程序在多 CPU 上并行在本质上是不同的,在单
CPU 上，操作系统利用时间片轮转算法在一段时间内依次调度执行多个程序，宏观上多道
程序并发运行、微观上仍是串行执行；在多 CPU 上，同一时刻可有多个程序分别在多个
CPU 上并行执行，而某个程序也可能同时在多个 CPU 上并行执行。
前者实现时应考虑的因素：
① 在多道程序环境下如何向用户提供服务；
② 在并发程序之间如可正确传递消息（通信）；
③ 如何对 CPU 进行调度，保证每个用户相对公平地得到 CPU；（CPU 是一个只可调
度，不可分配的资源）
后者实现时应考虑的因素：
① 在执行多道程序时应如何分配程序给 CPU
② 多 CPU 之间的通信问题
③ 在多 CPU 上并行执行一个程序时如何调度和分配 CPU
④
9．说明下列活动时属于哪种至于关系？
（1）若干同学去图书馆借书；
（2）两队进行篮球比赛；
（3）流水线生产中的各道工序；
（4）商品生产和社会消费；
答：
（1）互斥关系
（2）互斥关系
（3）同步关系
（4）同步关系
⑤
11．设有一台计算机，有两条 I/O 通道，分别接一台卡片输入机和一台打印机。
卡片机把
一叠卡片逐一输入到缓冲区 B1 中，加工处理后再搬到缓冲区 B2 中，并在打印机上印出。
问：
（1）系统要设几个进程来完成这个任务？
各自的工作是什么？
（2）这些进程间有什么样的相互制约关系？
（3）用 P．V 操作写出这些进程的同步算法。
（4）设系统中只有上述几个过程，用图表示出各自状态变迁情况及原因。
答：
（1）系统要设 3 个进程来完成这个任务；
第一个进程：
从卡片机把一叠卡片逐一输入到缓冲区 B1 中；
第二个进程：
加工处理后再搬到缓冲区 B2 中；
第三个进程：
从缓冲区 B2 读出，打印机印出。
（2）第一个进程从卡片机把一叠卡片逐一输入到缓冲区 B1 中，第二个进程加工处理 B1 中
的数据。
如果 B1 为空，则第二个进程无法进行；如果 B1 满了，第一个进程不能再进行。
第二个进程加工处理 B1 中的数据并搬到 B2 中，第三个进程从 B2 读出。
如果 B2 为空，
则第三个进程无法进行；如果 B2 满了，第二个进程无法进行。
（3）
P:
不能往满的 B1 送数据，设信号量 S1，初值为 k（k 为缓冲区 B1 的大小）
while（true）{
读一张卡片;
P（S1）;
数据送到缓冲区 B1;
V（S2）;
};
Q:
不能从空的 B1 读数据，设信号量 S2，初值为 0；不能往满的 B2 送数据，设信号量 S3，
初值为 l（l 为缓冲区 B2 的大小）
while（true）{
P（S2）;
从缓冲区 B1 读数据;
加工数据;
V（S1）;
P（S3）
加工的数据写入缓冲区 B2;
V（S4）
};
R:
不能从空的 B2 读数据，设信号量 S4，初值为 0；
while（true）{
P（S4）;
从缓冲区 B2 读数据;
V（S3）
打印;
};
（4）
卡片打印机
B1 未满
B1
进程一：
B1 非空
B2 未满
B2 非空
B2
运行
jB1满
kB1未满
j
●
●卡片全部读完
❍新的一批卡片作业
k
就绪
进程二：
❍
等待
运行
jB2满
kB2未满
j
●
●B1空
❍B1非空
就绪
进程三：
j
就绪
k
❍
运行
k
●
等待
j无条件
k B2空
● B2非空
等待
13 假定一个阅览室最多可容纳 100 人，读者进入和离开阅览室时都必须在阅览室门口的一
个登记表上标志（进入时登记，离开时去掉登记项），而且每次只允许一人登记或去掉登记，
问：
（1）应编写几个程序完成此项工作，程序的主要动作是些什么？
应设置几个进程？
进程
与程序间的对应关系如何？
（2）用 P、V 操作写出这些进程的同步通信关系。
答：
（1）应该编写四个程序完成工作，分别执行：
管理等待登入队列，登入并分配资源，管
理等待离开队列，登出并回收资源。
应设置 2 个进程，分别负责管理登入和负责管
理登出。
（2）设置 readercount=100，控制可进入的读者数
设置 mutex=1，控制操作登记表
登入进程：
{
P（mutex）
P（readercount）
分配阅览室资源
V（mutex）
}
登出进程：
{
P（mutex）
回收阅览室资源
V（readercount）
V（mutex）
}
17．假设一个系统的磁盘大小为 2kB，一个块的平均访问时间是 20 毫秒，一个有 40kB 的
进程由于资源请求此从运行状态变为阻塞态。
要确保将该进程换出，它必须保持阻塞多长
时间？
解：
阻塞时间：
T = 40/2 * 20 =400 （毫秒）
18.假使 A、B 两个火车站之间是单轨线，许多列车可以同时到达 A 站，然后经 A
站到 B 站，又列车从 A 到 B 的行驶时间是 t，列车到 B 站后的停留时间是 t/2。
试
问在该问题模型中，什么是临界资源？
什么是临界区？
答：
因为许多列车可以同时到达 A 站，所以 A 站不是互斥资源，而 A、B 之间的单轨线每
次只能允许一辆列车发出以后另一辆才能发出。
因为列车行驶时间为 t，B 的停留时间
为 t/2，所以只要在前一辆列车走完前 1/2 路程后再发车，到达 B 站时前一辆车也已离
开 B 站。
（1）A、B 间单轨线的前半段是临界资源。
（2）临界区：
列车在单轨线前半段上行驶
21 题 （测验的最后一题，类似，更简单）
由于有 m 个发送者，n 个接收者，k 大小的缓冲区；从单个的问题出发，发送者要么等待
在第 x 缓冲区（条件是缓冲区 x 未被清空，而发送者采用递增环状方式使用缓冲区）要么
发送到 x，发送完后需要唤醒所有接收进程。
接收进程不停的轮询缓冲区,也采用递增环状方式，如果缓冲区有内容，则收取，并
把此缓冲区的未接收数减一，如果减至 0，则置缓冲区为空。
综上所述，需要对每个缓冲区单位设置空，满，互斥量，未收取数
（empty，full，mutex，count）其中 full 是一个数组，记录每个接收者的情况，防
止重复接收，mutex 主要用来做 count 的互斥访问。
此外，还要设置全局的互斥变量 mutex。
Type BufferType = Record
msg:
MessageType;
count:
integer;
mutex:
semaphore; {初值为 1}
empty:
semaphore; {初值为 1}
full:
array [1..n] of semaphore；
{初值全为 0}
End
Varmutex:
semaphore; {初值为 1}
s:
integer;{初值为 0}
buff:
array [0..k-1] of BufferType;
{k 是缓冲区大小； n 是接收进程个数}
{ m 是发送进程个数，通过 s 进行“写互斥” }
Procedure Sender_i（i:
integer）;
{ i 为发送进程的标号}
Var s0, j:
integer;
Begin
Repeat
P（mutex）;
s0:
=s;
s:
=（s+1） mod k;
V（mutex）;
P（buff[s0].empty）；
在 buff[s0].msg 中写信息；
P（buff[s0].mutex）；
buff[s0].count:
=n;
V（buff[s0].mutex）;
For （j:
=1 to n do）
V（buff[s0].full[j]）;
Until false;
End
Procedure Recvr（i:
integer）;
{ i 为接收进程的标号}
Var j:
integer;
Begin
j:
=0;
Repeat
P（buff[j].full[i]）;
从 buff[j].msg 中读信息；
P（buff[j].mutex）；
buff[j].count:
= buff[j].count-1;
If （buff[j].count=0）
Then V（buff[j].empty）；
V（buff[j].mutex）;
j:
=（j+1） mod k
Until false;
End
22.<1>.信号量说明：
mutex，初值为１，记录可进入临界区的进程数;
互斥算法；
P（mutex）;
进入临界区；
V（mutex）;
结束；
<2>.信号量说明：
mutex，初值为 m，记录可进入临界区的进程数;
互斥算法；
P（mutex）;
进入临界区；
V（mutex）;
结束；
25.一家快餐店招有 4 种雇员：
（1）开票者，取顾客的订单；
（2）厨师，准备饭菜；
（3）包装员，把食物撞进袋中；（4）出纳，一手收钱一手交货。
每位雇员可以看作一个
在通信的顺序进程。
他们采用的是什么方式的进程间通信？
答：
开票者和厨师之间是管道通信。
开票者源源不断的把订单给厨师，一次可能给一张也
可能给多张，厨师一次可能拿走一张订单去做也可能拿走多张去做。
厨师和包装员之间是
信箱通信，他们之间有个信箱，可能就是一个小平台，厨师做好就把菜放上去，相当于放
进信箱 ，而包装员可以在任何时候取走那个菜。
包装员和出纳之间是消息缓冲通信，包装
员包号了就给出纳发消息，出纳得到消息就取走包好的饭菜然后出售。
29．计算系统 CPU 利用率。
答：
1）Q 等于无穷时，算法退化为 FIFO，这时 CPU 利用率为 T/（S+T）
2）Q>T 时，进程在用完时间片之前已被堵塞，因此 CPU 利用率仍为 T/（S+T）
3）ST /（（INT（T/Q） + 1）* S）+ T）
4）Q = S 时，当 S 远小于 T 时，CPU 在调度和运行进程的时间近似相等，CPU 利用率为
1/2
5）Q 趋于零时，几乎所有的时间都花在调度上，因此 CPU 利用率也趋于零。
34．巴拿马运河建在太平洋和大西洋之间。
由于太平洋和大西洋水面高度不同，有巨大落
差，所以运河中修建有 T（T>=2）级船闸，并且只能允许单向通行。
船闸依次编号为
1、2、…、T。
由大西洋来的船需经由船闸 T、T-1、…、1 通过运河到太平洋；由太平洋来
的船需经由船闸 1、2、…、T 通过运河到大西洋。
试用 P、V 操作正确解决大西洋和太平洋的船只通航问题
答：
来自不同方向的船只对船闸要互斥使用。
但如过有同方向的船只正在通行，则不用等
待。
对一个船闸设以下变量：
PtoAcount整型，记录此船闸正由太平洋往大西洋航行的船只 初值 0。
AtoPcount整型，记录此船闸正由大西洋往太平洋航行的船只 初值 0。
Mutex信号量，对 PtoAcount 互斥 初值 1
Mutex1信号量，对 AtoPcount 互斥 初值 1
Pass信号量初值 1
太平洋到大西洋的船：
P（mutex）;
PtoAcount:
=PtoAcount+1;
if PtoAcount = 1
then P（pass）;
V（mutex）;
过
P（mutex）
PtoAcount:
=PtoAcount-1;
if PtoAcount = 0;
then V（pass）;
V（mutex）;
大西洋到太平洋的船:
P（mutex1）;
AtoPcount:
=AtoPcount+1;
if AtoPcount = 1;
then P（pass）;
V（mutex1）;
过
P（mutex1）
AtoPcount:
=AtoPcount-1;
if AtoPcount = 0;
then V（pass）;
V（mutex1）;
32 题：
有 5 个带运行的作业，它们的估计运行时间分别是 9，6，3，5 和 x。
采用那种次序
的运行各种作业将得到最短的平均响应时间。
解：
采用最短作业优先法运行作业将得到最短平均相应时间。
具体执行顺序是（依赖 x） ：
1） x<=3 时 ，x → 3 → 5 → 6 → 9
2） 33） 54） 65） 935．
答：
设有 n 个柜台
需要考虑等待人数
如果没有顾客 则柜台需要等待 设置 empty = 0
如果顾客太多 则顾客需要等待 设置 Customer = 0
int CUSTOMER_NUM = 1;
int COUNTER_NUM = 1;
Customer
{
//取号码
P（MUTEX_CUSTOMER_NUM）;
int X = CUSTOMER_NUM;
CUSTOMER_NUM++;
V（MUTEX_CUSTOMER_NUM）;
//等待叫号
V（COUNTER）;
P（CUSTOMER）;
ACTION_CUSTOMER（X）;
}
Counter
{
int X;
REPEAT
//叫号
P（COUNTER）;
V（CUSTOMER）;
P（MUTEX_COUNTER_NUM）;
int X = COUNTER_NUM;
V（MUTEX_COUNTER_NUM）;
ACTION_COUNTER（X）;
UNTIL false;
}
37.对 PV 操作定义做如下修改
P（s）:
s:
=s-1;
If s<0
Then 将本进程插入相应队列末尾等待；
V（s）：
s:
=s+1;
If s<=0
Then
从等待队列队尾取一个进程唤醒，
插入就绪队列
问题：
（实现 4 个进程使用某一个需互斥使用的资源）
1）这样定义 P、V 操作是否有问题？
不合理：
先进后出；可能“无限等待”
2）先考虑用这样的 P、V 操作实现 N 个进程竞争使用某一共享变量的互斥机制。
思路：
令等待队列中始终只有一个进程。
将 “栈” 变成 “队列”
Var S:
array [1..n-1] of semaphore;
{ n 为进程数目；S[i]初值为 i；S[n-1]到
S[1]的作用好象是 n-1 层筛子 }
Procedure Pi;
Var i:
integer;
Begin
Repeat
Pre_Do_it（）;
For i:
=n-1 Downto 1 Do
P（S[i]）;
Do_It_In_Critical_Section;
For i:
=1 To n-1 Do
V（S[i]）;
Post_Do_it（）;
Until false;
End
3）对于 2）的解法，有无效率更高的方法。
如有，试问降低了多少复杂性？
上述解法每次都需要做 2（n-1）次 P/V 操作，
性能低下。
采用二叉树的思想，改进如下：
设有 4 个进程 P1..P4，
Var S1, S2, S3:
semaphore; {初值为 1}
Procedure P1;{ P2 is the same}
Begin
Repeat
P（S1）;
P（S3）;
Do_It（）;
V（S3）;
V（S1）;
Until false;
End;
Procedure P3;{ P4 is the same}
Begin
Repeat
P（S2）;
P（S3）;
Do_It（）;
V（S3）;
V（S2）;
Until false;
End;
假设共有 2N 个进程争用临界区；
时间复杂性：
2N -1vs N；空间复杂性：
2N-1 vs 2N-1
38 用进程通讯的办法解决生产者消费者问题问题（设有 N 个缓冲区）
生产者：
Void producer （void）
{
int item;
Message m;
While （TRUE）{
produce_item （&item）;
Receive （consumer, &m）;
Build_message （&m, item）;
Send （consumer, &m）;
}
}
消费者：
Void consumer （void）;
{
int item, I;
Message m;
For （i=0;iWhile （TRUE）{
Receive （ producer ,&m）；
Extract_item（ &m, &item）;
Send （producer ,&m）;
Consumer_item（item）;
}
}
39.用管程实现哲学家就餐问题
解法思想如下：
一个想用餐的哲学家首先拿他（她）的左边叉子，拿到后若他（她）的右边的叉子时
空闲的则拿起它开始用餐，否则，他（她）放下左边的叉子并重复这个过程。
该解法是非构造性的，即假设管程已经实现。
FUNCTION test_and_pick_up（i:
0..4）:
boolean;
BEGIN
IF fork [i]=used THEN
test_and_pick_up=false
ELSE
BEGIN
fork [i]:
=used;
test_and_pick_up:
=true
END
END;
PROCEDURE put_down（i:
0..4）;{放下}
BEGIN
fork [i]=free;
signal （queue [i]）;
END;
PROCEDURE initialize;{初始化}
VAR i:
0..4
BEGIN
FOR i:
=0 TO 4 DO
BEGIN
fork [i]:
=free;
END
END;
BEGIN
initialize
END;
每个哲学家内部定义一个局部变量：
VARwith_two_gorks:
Boolean;
i 号哲学家（i=0,..4,）的活动是这样的：
REPEAT
THINKING；
with_two_fork:
=false;
REPEAT
dining_philosophers.pick_up （i）;
IFdining_philosophers.test_and_pick_up（（i+1）MOD
5）THEN
with_two_fork:
=true
ELSE
dining_philosophers.put_down（i）;
UNTIL with_two_forks;
EATING;
dining_philosophers.put_down（i）;
dining_philosophers.put_down（（i=1） MOD 5）;
UNTIL false;
补充题:
写者优先问题：
reader
Repeat
P（s）;
P（mutex）;
RC:
=RC+1;
if RC=1 then P（w）;
V（mutex）;
V（s）;
reading;
P（mutex）;
RC:
=RC-1;
if RC=0 then V（w）;
V（mutex）;
Until false;
writer :
Repeat
P（k）;
WC:
=WC+1;
if WC=1 then P（s）;
V（k）;
P（w）;
writing;
V（w）;
P（k）;
WC:
=WC-1;
if WC=0 then V（s）;
V（k）;
Until false;
升级会员 