收藏
下载资源下载资源 加入VIP,免费下载

操作系统实验银行家算法共11页word资料.docx

上传人：b****5 文档编号：11648195 上传时间：2023-03-29 格式：DOCX 页数：14 大小：124.33KB
下载 相关 举报
操作系统实验银行家算法共11页word资料.docx_第1页
第1页 / 共14页
操作系统实验银行家算法共11页word资料.docx_第2页
第2页 / 共14页
操作系统实验银行家算法共11页word资料.docx_第3页
第3页 / 共14页
操作系统实验银行家算法共11页word资料.docx_第4页
第4页 / 共14页
操作系统实验银行家算法共11页word资料.docx_第5页
第5页 / 共14页
点击查看更多>>
下载资源
资源描述

操作系统实验银行家算法共11页word资料.docx

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

操作系统实验银行家算法共11页word资料.docx

操作系统实验银行家算法共11页word资料

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

课本、报刊杂志中的成语、名言警句等俯首皆是,但学生写作文运用到文章中的甚少,即使运用也很难做到恰如其分。

为什么?

还是没有彻底“记死”的缘故。

要解决这个问题,方法很简单,每天花3-5分钟左右的时间记一条成语、一则名言警句即可。

可以写在后黑板的“积累专栏”上每日一换,可以在每天课前的3分钟让学生轮流讲解,也可让学生个人搜集,每天往笔记本上抄写,教师定期检查等等。

这样,一年就可记300多条成语、300多则名言警句,日积月累,终究会成为一笔不小的财富。

这些成语典故“贮藏”在学生脑中,自然会出口成章,写作时便会随心所欲地“提取”出来,使文章增色添辉。

一、需求分析

家庭是幼儿语言活动的重要环境，为了与家长配合做好幼儿阅读训练工作，孩子一入园就召开家长会，给家长提出早期抓好幼儿阅读的要求。

我把幼儿在园里的阅读活动及阅读情况及时传递给家长，要求孩子回家向家长朗诵儿歌，表演故事。

我和家长共同配合，一道训练，幼儿的阅读能力提高很快。

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

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

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

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

“教书先生”恐怕是市井百姓最为熟悉的一种称呼，从最初的门馆、私塾到晚清的学堂，“教书先生”那一行当怎么说也算是让国人景仰甚或敬畏的一种社会职业。

只是更早的“先生”概念并非源于教书，最初出现的“先生”一词也并非有传授知识那般的含义。

《孟子》中的“先生何为出此言也？

”；《论语》中的“有酒食，先生馔”；《国策》中的“先生坐，何至于此？

”等等，均指“先生”为父兄或有学问、有德行的长辈。

其实《国策》中本身就有“先生长者，有德之称”的说法。

可见“先生”之原意非真正的“教师”之意，倒是与当今“先生”的称呼更接近。

看来，“先生”之本源含义在于礼貌和尊称，并非具学问者的专称。

称“老师”为“先生”的记载，首见于《礼记?

曲礼》，有“从于先生，不越礼而与人言”，其中之“先生”意为“年长、资深之传授知识者”，与教师、老师之意基本一致。

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

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

二、概要设计

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!

ENTERTHE

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置：首页 > 求职职场 > 简历

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1