操作系统实验银行家算法.docx

操作系统实验银行家算法.docx

《操作系统实验银行家算法.docx》由会员分享，可在线阅读，更多相关《操作系统实验银行家算法.docx（17页珍藏版）》请在冰豆网上搜索。

操作系统实验银行家算法

用银行家算法和随机算法实现资源分配

一、需求分析

为了了解系统的资源分配情况，假定系统的任何一种资源在任一时刻只能被一个进程使用。

任何进程已经占用的资源只能由进程自己释放，而不能由其他进程抢占。

当进程申请的资源不能满足时，必须等待。

因此，只要资源分配算法能保证进程的资源请求，且不出现循环等待，则系统不会出现死锁。

要求编写系统进行资源调度的程序。

一个是随机动态地进行资源分配的模拟程序，即只要系统当前剩余资源满足进程的当前请求，就立即将资源分配给进程，以观察死锁产生情况；一个是采用银行家算法，有效地避免死锁的产生。

二、概要设计

1、系统的主要功能

采用银行家算法，有效地避免死锁的产生。

2、运行环境要求

WINDOWSVC

3、实验内容概述

模拟进程的资源分配算法，了解死锁的产生和避免的方法。

三、详细设计

要求

（1）设计3~4个并发进程，共享系统的10个同类不可抢占的资源。

各进程动态进行资源的申请和释放。

（2）用银行家算法和随机算法分别设计一个资源分配程序，运行这两个程序，观察系统运行情况，并对系统运行的每一步情况进行显示。

提示

（1）初始化这组进程的最大资源请求和依次申请的资源序列。

把各进程已占用和需求资源情况记录在进程控制块中。

假定进程控制块的格式如图所示，其中进程的状态有：

就绪、等待和完成。

当系统不能满足进程的资源请求时，进程处于等待态。

资源需求总量表示进程运行过程中队资源的总的需求量。

进程名

状态

当前申请量

资源需求总量

已占资源量

能执行完标志

已占资源量表示进程目前已经得到但还未归还的资源量。

因此，进程在以后还需要的剩余资源量等于资源需求总量减去已占资源量。

显然每个进程的资源需求总量不应超过系统拥有的资源总量。

（2）银行家算法分配资源的原则是：

当某个进程提出资源请求时，假定先分配资源给它，然后查找各进程的剩余请求，检查系统的剩余资源量是否由于进程的分配而导致系统死锁。

若能，则让进程等待，否则，让进程的假分配变为真分配。

①查找各进程的剩余请求，检查系统的剩余资源量是否能满足其中一进程。

如果能，则转②②将资源分配给所选的进程，这样，该进程已获得资源量最大请求，最终能运行完。

标记这个进程为终止进程，并将其占有的全部资源归还给系统。

重复第①步和第②步，直到所有进程都标记为终止进程，或直到一个死锁发生。

若所有进程都标记为终止进程，则梯田的初始状态是安全的，否则为不安全的。

若安全，则正式将资源分配给它，否则，假定的分配作废，让其等待。

③由于银行家算法可以避免死锁，为了观察死锁现象的发生，要求采用两个算法：

银行家算法和随机算法。

随机算法的分配原则是：

当进程申请资源时，如果系统现存资源数能满足进程的当前申请量，就把资源分配给进程，否则，让其等待。

这样，随机算法可能引起死锁。

一

资源分配模拟算法总框图

四、源代码

#include

#include

#include

usingnamespacestd;

constintTASK_RUNNING=0;

constintTASK_SUCCEED=1;

constintTASK_WAITTING=2;

constintTASK_RLength=10;

intRcs-left=RLength;

ofstreamff（"result.txt"）;

classpcb

{

public:

intp_pid;

intp_stat;

intp_apply;

intp_occupy;

boolp_issuc;

intp_require;

pcb（intid,intrequire）

{

p_pid=id;

p_require=require;

p_stat=TASK-RUNNING;

p_occupy=0;

p_issuc=false;

p_apply=0;

}

friendostream&operator<<（ostream&cout,constpcb&p）

{

cont<

returncout;

}

};

voidrand（vector&resource,vector&pgrp）;

voidbanker（vector&resource,vector&pgrp）;

intmain（）

vectorresource;

vectorpgrp;

vector:

:

iteratorr;

vector:

:

iteratorp;

cout<<"ENTERTHEMAXNUMBERFORTHEREQUESTEDRESOURCE:

"<

cout<<"ID\tREQUESTED"<

ff<<"ENTERTHEMAXNUMBERFORTHEREQUESTEDRESOURCE:

"<

ff<<"ID\tREQUESTED"<

intid,qty;

for（inti

（1）;i<=4;i++）

{

do

{

cout<

ff<

cin>>qty;

ff<

}while（qty>Rcs_left||qty<1）;

pgrp.insert（pgrp.begin（）,pcb（i,qty））;

}

//输入各进程申请资源的总量，以及初始化各进程；

cout<<"ALOGRITHM"<

<<"Random（R）"<<'\t'

<<"Banker（B）"<

<<"ANYOTHERKEYTOQUIT"<

ff<<"ALOGRITHM"<

<<"Random（R）"<<'\t'

<<"Banker（B）"<

<<"ANYOTHERKEYTOQUIT"<

charchoice;

cin>>choice;

ff<

if（choice=='R'||choice=='r'）

rand（resource,pgrp）;

elseif（choice=='B'||choice=='b'）

banker（resource,pgrp）;

else

return（0）;

rerurn

（1）;

}

voidrand（vector&resource,vector&pgrp）;

{

vector:

:

iteratorp,q;

vector:

:

iteratorcurrent;

vector:

:

iteratorr;

inttemp;

cout<<"NOW-----BANKERALOGRITHM"<

ff<<"NOW-----BANKERALOGRITHM"<

for（;;）

{

//selectaTASK_RUNNIGprocess,maybedifferentfromtheformerone;

for（p=pgrp.begin（）;p!

=pgrp.end（）;p++）

{

if（p-p_stat=TASK-RUNNING;）

{

current=p;

break;

}

}

if（current->p_apply==0）

{

cout<<"ENTERTHEAPPLYFORTHEPROCESS\n"<p_pid<<'\t';

ff<<"ENTERTHEAPPLYFORTHEPROCESS\n"<p_pid<<'\t';

cin>>temp;

ff<

while（temp>p->p_require-p->p_occupy）

{

cout<<"beyondtherealneed!

"<

cout<<"ENTERTHEAPPLYFORTHEPROCESS\n"<p_pid<<'\t';

ff<<"beyondtherealneed!

"<

ff<<"ENTERTHEAPPLYFORTHEPROCESS\n"<p_pid<<'\t';

cin>>temp;

ff<

}

p->p_apply=temp;

}

//inputtheapplyforthecurrentprocess;

if（current->p_apply>Rcs_left）

{//hasproblem

//applytoomuch,pleasewait---

current->p_stat=TASK_WAITTING;

cout<p_pid<<"iswaitting\n";

ff<p_pid<<"iswaitting\n";

for（p=pgrp.begin（）;p!

=pgrp.end（）;p++）

{

if（p->p_stat==TASK_RUNNING）break;

}

if（p==pgrp.end（））

{

cout<<"LOCKED!

!

!

"<

ff<<"LOCKED!

!

!

"<

exit

（1）;

}

//满足该进程当前的申请

resource.insert（resource.begin（）,current->p_apply,current->p_pid）;

cout<p_pid<

cout<

ff<p_pid<

ff<

Rcs_left-=current->p_apply;

current->p_occupy+=current->p_apply;

current->p_occupy=0;

//看该进程是否已满足

if（current->p_occupyp_require）

{

pcbproc（*current）;

pgrp.erase（current）;

pgrp.insert（pgrp.end（）,proc）;

//current->p_apply=0;

//deletecurrentandinsertintotheend

continue;//goonandshouldselectanotherprocess

}

//succeed

cout<

!

"<

ff<

!

"<

Rcs_left+=current->p_apply;

resource.clear（）;

current->p_stat=TASK_SUCCEED;

//

current->p_occupy=0;

for（p=pgrp.begin（）;p!

=pgrp.end（）;p++）

{

if（p->p_stat==TASK_WAITTING）

break;

}

if（p==pgrp.end（））

{

for（q=pgrp.begin（）;q!

=pgrp,end（）;q++）

{

if（q->p_stat==TASK_RUNNING）

break;

}

if（q==pgrp,end（））

{

cout<<"SUCCEED!

!

"<

ff<<"SUCCEED!

!

"<

exit（0）;

}

elsecontinue;

//thereisaprocessinthequeue;

}

for（p=pgrp.begin（）;p!

=pgrp.end（）;p++）

{

if（p->p_stat==TASK_WAITTING&&Rcs_left>=p->p_apply）

break;

}

if（p!

=pgrp.end（））

{

p->p_stat==TASK_RUNNING;

pcbproc（*p）;

pgrp.erase（p）;

pgrp.insert（pgrp.end（）,proc）;

continue;

}

else

{

cout<<"LOCKED!

!

!

"<

ff<<"LOCKED!

!

!

"<

exit

（1）;

}

}

}

voidbanker（vector&resource,vector&pgrp）;

{

vector:

:

iteratorp;

vector:

:

iteratorr;

vector:

:

iteratorcurrent,q;

vector:

:

iteratorr;

pcbproc（0,0）;

intlength;

cout<<"NOW-----BANKERALOGRITHM"<

ff<<"NOW-----BANKERALOGRITHM"<

for（;;）

{

for（p=pgrp.begin（）;p!

=pgrp.end（）;p++）

{

if（p->p_stat==TASK_RUNNING）

{

current=p;

break;

}

}

if（current->p_apply==0）

{

cout<<"ENTERTHEAPPLYFORTHEPROCESS\n"<p_pid<<'\t';

ff<<"ENTERTHEAPPLYFORTHEPROCESS\n"<p_pid<<'\t';

cin>>current->p_apply;

ff<p_apply<

while（current->p_apply>current->p_require>current->p_occupy）

{

cout<p_pid<<'\t';

ff<p_pid<<'\t';

cin>>current->p_apply;

ff<p_apply<

}

}

if（p->p_apply>Rcs_left;

{

current->p_stat=TASK_WAITTING;

proc=*current;

pgrp.erase（current）;

pgrp.insert（pgrp.end（））,proc）;

cout<p_pid<<"iswaiting!

"<

ff<p_pid<<"iswaiting!

"<

continue;

}

//假定对申请资源的进程分配资源

pcbbackup（*current）;

//backup

length=Rcs_left;

current->p_occupy+=current->p_apply;

length-=current->p_apply;

if（current->p_occupy==current->p_require）

length-=current->p_require

current->p_issuc=true;

for（p=pgrp.begin（）;p!

=pgrp.end（）;p++）

{

if（p->p_stat==TASK_SUCCEED）CONTINUE;

if（p==current&&p-p_issuc==true）

continue;

if（（p->p_require-p->p_occupy）>length）continue;

else

{

p->p_issue=true;

length+=p->p_occupy;

continue;

}

}

//检查是否还有标志位未设置的进程

for（p=pgrp.begin（）;p!

=pgrp.end（）;p++）

{

if（p->p_issuc==false&&p->p_stat!

=TASK_SUCCEED）break;

}

if（p!

=pgrp.end（））

{

current->p_occupy=backup.p_occupy;

current->p_stat=TASK_WAITTING;

cout<p_pid<<"iswaiting."<

ff<p_pid<<"iswaiting."<

proc=*current;

pgrp.erase（current）;

pgrp.insert（pgrp.end（））,proc）;

for（p=pgrp.begin（）;p!

=pgrp.end（）;p++）

p->p_issuc==false;

continue;

}

//分配安全，可对程序进行实际的分配

resource.insert（resource.end（）,current->p_apply,current->p_pid）;

Rcs_left-=current->apply;

cout<p_pid<<"get"<p_apply<<"resource（s）!

"<

ff<p_pid<<"get"<p_apply<<"resource（s）!

"<

current->p_apply=0;

if（current->p_occupyp_require）

{

proc=*current;

pgrp.erase（current）;

pgrp.insert（pgrp.end（））,proc）;

for（p=pgrp.begin（）;p!

=pgrp.end（）;p++）

p->p_issuc==false;

continue;

}

current->p_stat=TASK_SUCCEED

current->p_occupy=0;

cout<p_pid<<"hasfinished!

!

!

"<

ff<p_pid<<"hasfinished!

!

!

"<

//归还全部系统资源

resource.clear（）;

Rcs_left+=current->p_require;

for（p=pgrp.begin（）;p!

=pgrp.end（）;p++）

{

if（p->p_stat==TASK_WAITTING）

break;

}

if（p==pgrp.end（））

{

for（p=pgrp.begin（）;q!

=pgrp.end（）;q++）

{

if（q->q_stat==TASK_RUNNING）

break;

}

if（q==pgrp.end（））

{

cout<

!

"<

ff<

!

"<

exit（0）;

}

else

continue;

}

proc=*p;

pgrp.erase（p）;

pgrp.insert（pgrp.end（））,proc）;

p->p_stat=TASK_RUNNING;

continue;

}

}

五、系统测试及调试

1、实际测试数据

/*程序演示结果如下：

*/

ENTERTHEMAXNUMERFORTHEREQUESTEDRESOURCE:

IDREQUESTED

13

25

37

49

ALOGRITHM

Random（R）Banker（B）

ANYOTHERKEYTOQUIT

r

NOW------BANKERALOGRITHM

ENTERTHEAPPLYFORTHEPROCESS

42

2resourceareacceptedfor4

ENTERTHEAPPLYFORTHEPROCESS

33

3resourceareacceptedfor3

ENTERTHEAPPLYFORTHEPROCESS

25

5resourceareacceptedfor2

process2hassucceed!

ENTERTHEAPPLYFORTHEPROCESS

12

2resourceareacceptedfor1

ENTERTHEAPPLYFORTHEPROCESS

44

4iswaiting

ENTERTHEAPPLYFORTHEPROCESS

32

2resourceareacceptedfor3

ENTERTHEAPPLYFORTHEPROCESS

12

beyondtherealneed!

ENTERTHEAPPLYFORTHEPROCESS

11

1resourceareacceptedfor1

process1hassucceed!

!

LOCKED!

!

!

*/

六、心得体会

程序基本实现了银行家算法的功能，并在其基础上考虑了输出显示的格式的美观性、输入错误要求重新输入等几个方面，尽可能的使程序完整一些。

由于能力有限，所以在紧张的的编写和调试过程中遇到了许多的问题，通过查询资料、翻阅