内容发布更新时间 : 2024/4/28 17:57:03星期一 下面是文章的全部内容请认真阅读。

精品文档

V(emptyl)：

print last number; until flase; end

P02：begin Repeat

P(full2)；

take from buffer; V(empty2);

print last number; until false end parend end

3.

信号量：nonf1、none1：输入进程与计算进程同步，buf1是否为空；

nonf2 、none1：计算进程与输出进程同步，buf2是否为空；

s1、s2：分别互斥使用buf1和buf2 procedure input begin

wait(nonf1) wait(s1)

put(data); signal(s1); signal(none1); until false end;

procedure compute begin

wait(none1); wait(s1); data=get();

data=calculate(data); signal(s1); signal(nonf1); wait(nonf2); wait(s2); put(data); signal(s2); signal(none2); until false end;

procedure output begin

wait(none2); wait(s2); data=get();

print(data); signal(s2);

。

11欢迎下载

精品文档

signal(nonf2); until false end;

4.

（1）利用安全性算法对T0时刻的资源分配情况进行分析，结果如下： Work P3 P1 P2 P4 P5 1 6 3 2 9 8 2 9 11 3 9 11 3 9 13 Need 1 0 0 1 2 7 0 7 5 0 6 4 0 6 2 Allocation 1 3 5 0 0 3 1 0 0 0 0 2 0 0 1 Work + Allocation Finish 2 9 8 2 9 11 3 9 11 3 9 13 3 9 14 true true true true true 系统处于安全状态，安全序列为：P3，P1，P2，P4，P5。

（2）P1发出请求向量Request1（1，0，1）,系统按银行家算法进行检查： 1) Request1（1，0，1） <= Need1(1，2，6) 2) Request1（1，0，1）<= Available(1，6，3)

3) 系统先假定可为P1分配资源，并修改Available、 Allocation1、 Need1向量，资源变化情况如下： max

Allocation

A B C

Available Need

A B C A B C

A B C

P1 1 2 10 0 0 4 0 6 2 0 1 6 P2 1 7 5 1 0 0 0 7 5 P3 2 3 5 1 3 5 1 0 0 P4 0 6 4 0 0 2 0 6 2 P5 0 6 5 0 0 1 0 6 4

剩余资源可满足P4，分给P4给还后（0,6,4）可满足P5，分配P5归还后（0,6,5）不满足其它进程要求，即不能实施分配，因为分配后找不到安全序列，系统将处于不安全状态。

5.

2. (1 )采用先来先服务(FCFS)算法。

作业名 J1 J2 J3 J4 J5 提交时间/h 10.1 10.3 10.5 10.6 10.7 需执行时间/h 0.3 0.5 0.4 0.3 0.2 开始运行时间/h 10.1 10.4 10.9 11.3 11.6 完成时间/h 10.4 10.9 11.3 11.6 11.8

J1，J2，J3，J4，J5

T=[(10.4-10.1)+(10.9-10.3)+(11.3-10.5)+(11.6-10.6)+(1l.8-10.7)]/5 =3.8/5=0.76h

T=[(10.4-10.1)/0.3+(10.9-10.3)/0.5+(11.3-10.5)/0.4+(11.6-10.6)/0.3+(1l.8-10.7)/0.2]/5

=13.033/5=2.61

。

12欢迎下载

精品文档

(2) 短作业优先调度(SJF)算法。

作业名 J1 J2 J3 J4 J5 提交时间/h 10.1 10.3 10.5 10.6 10.7 需执行时间/h 0.3 0.5 0.4 0.3 0.2 开始运行时间/h 10.1 10.4 11.4 11.1 10.9 完成时间/h 10.4 10.9 11.8 11.4 11.1

J1，J2，J5，J4，J3

T=[(10.4-10.1)+(10.9-10.3)+(11.8-10.5)+(11.4-10.6)+(11.1-10.7)]/5 =3.4/5=0.68h

T=[(10.4-10.1)/0.3+(10.9-10.3)/0.5+(11.8-10.5)/0.4+(11.4-10.6) (11.1-10.7)/0.2]/5 =10.117/5=2.02

(3) 高响应比优先调度算法。 作业名 J1 J2 J3 J4 J5 提交时间/h 10.1 10.3 10.5 10.6 10.7 需执行时间/h 0.3 0.5 0.4 0.3 0.2 开始运行时间/h 10.1 10.4/10.7 10.6/11.5 11.2 11.0 完成时间/h 10.4 11.0 11.8 11.5 11.2 /0.3+

J1，J2，J3，J2，J5，J4，J3

T=[(10.4-10.1)+(11.0-10.3)+(11.8-10.5)+(11.5-10.6)+(11.2-10.7)]/5 =3.7/5=0.72h

T=[(10.4-10.1)/0.3+(11.0-10.3)/0.5+(11.8-10.5)/0.4+(11.5-10.6) (11.2-10.7)/0.2]/5 =11.15/5=2.23

/0.3+

6.

(1) 执行完序号为6的申请时，各进程的状态和已占的资源数如表所示；

P等待 Q就绪或运行 R等待 已占用资源4个 已占用资源4个 已占用资源2个

根据单项银行家算法，过程为： 1) R申请2个资源时，剩余资源可使各进程运行结束，所以这个分配是安全的，故将2个资源分给R；

2) 同理，P、Q分别申请4，2个资源时，剩余资源可使各进程运行结束，所以这个分配也是安全的，故将4、2个资源分给P、Q；

3) P申请2个资源时，系统此刻剩余资源数为2，如果将这两个资源分给P，系统就没有资源了。这时的P、Q、R都还需要资源才可运行完，这样，P、Q、R将都进入阻塞状态，所以P申请的这两个资源不能分配。

4) 同理，接下来R欲申请1个资源也是不安全的分配，故不能分给。

5) Q申请2个资源时，假定操作系统分给它，Q进程将运行结束，Q释放的资源又可使P运行结束;P运行结束，释放的资源又可使R运行结束。所以这个分配是安全的，故将2个资源分给Q。

。

13欢迎下载

精品文档

(2)不会死锁，因为银行家算法在任何时候均保证至少有一个进程能得到所需的全部资源，这样，得到资源的进程能及时归还资源供其他进程使用。

7.

从概念上讲，系统中各进程在逻辑上是独立的，它们可以按各自的速度向前推进。但由于它们共享某些临界资源，因而产生了临界区问题。对于具有临界区问题的并发进程，它们之间必须互斥，以保证不会同时进入临界区。

这种算法不是安全的。因为，在进入临界区的enter-crtsec（）不是一个原语操作，如果两个进程同时执行完其循环（此前两个flag均为false），则这两个进程可同时进入临界区。

8.

① 分配策略为：当进程Pi申请ri类资源时，检查ri中有无可分配的资源：有则分配给Pi；否则将Pi占有的资源全部释放而进入等待状态。(Pi等待原占有的所有资源和新申请的资源)

② 资源分配过程： 剩余资源 进程A：(3，2，1) (1，0，1) 进程B：(1，0，1) (0，0，0) 进程A：(0，1，0)(不满足) (3，2，1) A的所有资源被剥夺，A处于等待

进程C：(2，0，0) (1，2，1) C，B完成之后，A可完成。

9.

生产者-消费者问题的一个变形，一组生产者A1，A2．...，An和一组消费者B1，B2，...，Bm共用k个缓冲区，每个缓冲区只要写一次，但需要读m次。因此，我们可以把这一组缓冲区看成m组缓冲区，每个发送者需要同时写m组缓冲区中相应的m个缓冲区，而每一个接收者只需读它自己对应的那组缓冲区中的对应单元。

设置一个信号量mutex实现诸进程对缓冲区的互斥访问；两个信号量数组empty[m]和full[m]描述m组缓冲区的使用情况。mutex的初值为l，数组empty中元素初值为k，数组full中的元素初值为0。其同步关系描述如下：

int mutex,empty[m],full[m]； int i; mutex=1；

for(i=0;i<=m-1；i++) {

empty[i]=k； full[i]=0； }

main( ) {

cobegin A1()； A2()；

。

14欢迎下载

精品文档

… An()； B1()； B2()； … Bm()； coend

}

send() /*发送消息 */ {

in i；

for(i=0；i<=m-1；i++) P(empty[i])； P(mutex)；

将消息放入缓冲区； V(mutex)；

for(i=0；i<=m-1；i++) V(full[i])； }

receive(i) /*接收消息 */ {

p(full[i])； P(mutex)；

将消息从缓冲区取出； V(mutex)； V(empty[i])； }

Ai() /*因发送进程A1，A2，...，An的程序类似。这里只给出进程Ai的描述。*/ {

while(1) {

send()； } }

Bi() /* 因接收进程B1，B2，…，Bm的程序类似这里只给出进程Bi的描述 */ {

while(1) {

recive(i)； } }

。

15欢迎下载