操作系统原理1-3章答案黑新宏胡元义主编

最新推荐文章于 2023-04-19 12:23:08 发布

bueke

最新推荐文章于 2023-04-19 12:23:08 发布

阅读量1.4w

点赞数 38

分类专栏：操作系统原理文章标签：操作系统原理答案黑新宏胡元义主编

本文链接：https://blog.csdn.net/bueke/article/details/100533508

版权

操作系统原理专栏收录该内容

2 篇文章 4 订阅

订阅专栏

在这里插入图片描述

第1章引论
一、单项选择题
1.A 2. C 3. D 4. A 5.A 6. C 7. C 8. D 9. C 10.C
11. D 12.A 13.C 14.D 15.D 16.C 17.D 18.C 19.B 20.C
21.D 22.D 23.C 24.B 25.C 26.B

二、判断题
1.错误 2. 错误 3.错误 4. 错误 5.错误 6.错误 7.正确 8.错误 9.错误 10.错误
11.正确 12.错误 13.正确 14.错误 15.错误 16.正确 17.错误 18.错误 19.正确
20.正确 21.正确

第2章处理器管理
一、单项选择题
1.D 2. A 3.A 4. C 5.C 6. C 7. A 8. C 9. B 10.C
11. C 12.D 13.A 14.A 15.D 16.A 17.B 18.B 19.B 20.A
21.A 22.B 23.D 24.B 25.C 26.C 27.C 28.C 29.D 30.B
31.D 32.B 33.C 34.C D 35.B 36.A
二、判断题
1.错误 2. 错误 3.错误 4. 错误 5.错误 6.错误 7. 错误8.正确 9.错误 10.错误
11. 错误12.正确13. 错误14.错误 15.错误 16. 错误 17. 正确 18.错误 19.错误 20.错误
四、应用题
2. 由于短作业优先调度算法使得系统平均响应时间最短：
（1）当0<x<=3时应采用的运算次序为x，3，5，6，9
（2）当3<x<=5时应采用的运算次序为3，x， 5，6，9
（3）当5<x<=6时应采用的运算次序为3，5，x，6，9
（4）当6<x<=9时应采用的运算次序为3，5，6，x，9
（5）当9<x时应采用的运算次序为3，5，6， 9 ，x
3.
（1）采用先来先服务调度算法的作业运行情况：
作业执行次序提交时间运行时间等待时间开始时间完成时间周转时间带权周转时间
1 8.0 1.0 0 8.0 9.0 1.0 1.0
2 8.5 0.5 0.5 9.0 9.5 1.0 2.0
3 9.0 0.2 0.5 9.5 9.7 0.7 3.5
4 9.1 0.1 0.6 9.7 9.8 0.7 7.0
作业平均周转时间 T=（1.0+1.0+0.7+0.7）/4=0.85
作业平均带权周转时间 W=（1.0+2.0+3.5+7.0）/4=3.375

（2）采用短作业优先调度算法的作业运行情况：
作业执行次序提交时间运行时间等待时间开始时间完成时间周转时间带权周转时间
1 8.0 1.0 0 8.0 9.0 1.0 1.0
2 9.0 0.2 0 9.0 9.2 0.2 1.0
3 9.1 0.1 0.1 9.2 9.3 0.2 2.0
4 8.5 0.5 0.8 9.3 9.8 1.3 2.6
作业平均周转时间 T=（1.0+0.2+0.2+1.3）/4=0.675
作业平均带权周转时间 W=（1.0+1.0+2.0+2.6）/4=1.65

（3）采用高相应比优先算法的作业运行情况：
作业执行次序提交时间运行时间等待时间开始时间完成时间周转时间带权周转时间
1 8.0 1.0 0 8.0 9.0 1.0 1.0
2 8.5 0.5 0.5 9.0 9.5 1.0 2.0
3 9.1 0.1 0.4 9.5 9.6 0.5 5.0
4 9.0 0.2 0.6 9.6 9.8 0.8 4.6
作业平均周转时间 T=（1.0+1.0+0.5+0.8）/4=0.825
作业平均带权周转时间 W=（1.0+2.0+5.0+4.0）/4=3

采用先来先服务调度算法作业运行情况
作业次序提交时间运行时间等待时间开始时间完成时间周转时间
1 0.0 8.0 0.0 0.0 8.0 8.0
2 0.4 4.0 7.6 8.0 12.0 11.6
3 1.0 1.0 11.0 12.0 13.0 12.0
作业平均周转时间（8.0+11.6+12.0）/3=10.53

采用短作业优先调度算法作业运行情况
作业次序提交时间运行时间等待时间开始时间完成时间周转时间
1 0.0 8.0 0.0 0.0 8.0 8.0
2 1.0 1.0 7.0 8.0 9.0 8.0
3 0.4 4.0 8.6 9.0 13.0 12.6
作业平均周转时间（8.0+8.0+12.6）/3=9.53

作业1达到后暂不投入运行，待3个作业到齐后再按短作业优先算法调度执行。
推迟的短作业优先调度算法作业运行情况
作业次序提交时间运行时间等待时间开始时间完成时间周转时间
3 1.0 1.0 0.0 1.0 2.0 1.0
2 0.4 4.0 1.6 2.0 6.0 5.6
1 0.0 8.0 6.0 6.0 14.0 14.0
作业平均周转时间（1.0+5.6+14.0）/3=6.87

在这里插入图片描述
1）J1从开始到运行完成需要80ms，J2从开始到运行完成需要90ms，J3从开始到运行完成需要90ms.
（2）CPU利用率=CPU有效工作时间/（CPU有效工作时间＋CPU空闲时间）
　　　　　＝70/(70+20)=77.78%
（3）IO1利用率= IO1有效工作时间/（IO1有效工作时间＋IO1空闲时间）
=70/(70+20)=77.78%

（1）每道作业的运行经历两级调度：作业调度和进程调度。作业调度采用短作业优先调度算法，进程调度采用基于优先数的抢占式调度算法，即高优先级进程可以抢占低优先级进程所占用的CPU。只有在作业调度程序将作业装入内存后才能参与进程调度，本题的批处理系统为两道作业系统，即内存中最多允许有两道作业。
10：00时，作业A到达并且投入运行；
10：20时，作业B达到且优先级高于作业A，所以进程调度程序调度作业B投入运行，作业A进入就绪队列；
10：30时，作业C到达，内存中已有两道作业，所以作业C进入作业后备队列中等待；
10：50时，作业B运行结束且作业D到达。按短作业优先调度策略，作业D被调入内存并进入就绪队列，而就绪队列中作业A的优先级高于作业D，所以进程调度程序调度作业A运行；
11：10时，作业A运行结束，作业C被调入内存进入就绪队列，因作业C的优先级高于作业D，所以进程调度程序调度作业Ｃ运行；
12：00时，作业C运行结束，进程调度程序调度作业D运行；
12：20时，作业D运行结束，此时就绪队列中无可调度执行的作业，即全部作业都运行结束。
（2）各作业执行的周转时间：
作业A：70分钟；作业B：30分钟；作业C：90分钟；作业D：90分钟
作业的平均周转时间为：（70+30+90+90）/4=70分钟

第3章进程同步与通信
一、单项选择题

D 2. D 3. D 4. C 5.D 6. D 7. C 8. C 9. C 10.D
B 12.C 13.D 14.C 15.B 16.C 17.C 18.D 19.A 20.C
21.C 22.D 23.C 24.C 25.C 26.B 27.A 28.D 29.B 30.D

二、判断题

正确 2. 错误 3.错误 4. 错误 5.正确6.错误 7.正确 8. 正确9. 正确10.错误
错误12.错误 13.正确 14.错误 15.错误 16.正确 17.错误

Semaphore mutex;
Mutex.value=100;
cobegin
process reader_i() / /i=1,2,3……
{
P(mutex);
进入阅览室;
阅读;
退出阅览室;
V(mutex);
}
Coend

进程P1 进程P2

P(S1) P(S2)

捡一白子捡一黑子

V(S1) V(S2)

先让进程P1捡白子，则信号量S1.value 和S2.value的初值分别为1和0：
Semaphore S1,S2;
S1.value=1; S2.value=0;
cobegin
process P1( )
{
while(白子不空)
{
P(S1);
捡白子;
V(S2);
}
}
process P2( )
{
while(黑子不空)
{
P(S2);
捡黑子;
V(S1);
}
}
coend

R M P的同步关系用并发程序实现如下:
Semaphore a,b,c;
a.value=b.value=c.value=1;
cobegin
process R()
{
while (1)
{ P©;
从输入设备读一个记录到缓冲区;
V(a);
}
}

process M()
{
while (1)
{ P(a);
在缓冲区中加工读入的记录;
V(b);
}
}

Semaphore fork1,fork2,knife1,knife2;
fork1.value=fork2.value=knife1.value=knife2lvalue=1;
cobegin
process P_i( ) //i=0,1,2,3
{
while(1)
{
讨论问题;
if (i0||i3) P(knife1)
else P(knife2);
if (i0||i1) P(fork1)
else P(fork2);
进餐;
if (i0||i3) V(knife1)
else V(knife2);
if (i0||i1) V(fork1)
else V(fork2);
}
}
coend

Semaphore keyboard,disk,mutex;
Keyboard.value=0, disk.value=0, mutex.value=1;
cobegin
process R1()
{
while (1)
{
P(mutex);
从键盘读数到缓冲区B;
V(keyboard);
}
}

process R2()
{
while (1)
{
P(mutex);
从键盘读数到缓冲区B;
V(disk);
}
}

process W1()
{
while (1)
{
P(keyboard);
从缓冲区B取出数据打印;
V(mutex);
}
}
process W2()
{
while (1)
{
P(disk);
从缓冲区B取出数据打印;
V(mutex);
}
}
Coend

Semaphore mutex, empty, apple,orange;
mutex.value=1, empty.value=2, apple.value=orange.value=0;
cobegin
process father()
{
while(1)
{
P(empty);
P(mutex);
向盘中放苹果;
V(mutex);
V(apple);
}
}

process mother()
{
……
}

process daughter_i()
{
while(1)
{
P(apple);
P(mutex);
取盘中苹果;
V(mutex);
V(empty);
吃苹果;
}
}

process son_i()
{
……
}

Coend