银行家算法课程设计报告.docx

银行家算法课程设计报告.docx

《银行家算法课程设计报告.docx》由会员分享，可在线阅读，更多相关《银行家算法课程设计报告.docx（21页珍藏版）》请在冰豆网上搜索。

银行家算法课程设计报告

武汉理工大学华夏学院

课程设计报告书

课程名称：

操作系统原理

题目：

编程序模拟银行家算法

系名：

信息工程系

专业班级：

计应2091

姓名：

刘星宇

学号：

10225509111

指导教师:

苏永红

11年7月5日

课程设计任务书

学生姓名：

刘星宇专业班级：

计应2091

指导教师：

苏永红工作单位：

设计题目：

编程序模拟银行家算法

初始条件：

Linux操作系统，GCC编译环境

要求完成的主要任务：

主要任务：

银行家算法是避免死锁的一种重要方法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。

加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。

思想：

将一定数量的资金供多个用户周转使用，当用户对资金的最大申请量不超过现存资金时可接纳一个新客户，客户可以分期借款，但借款总数不能超过最大的申请量。

银行家对客户的借款可以推迟支付，但是能够使客户在有限的时间内得到借款，客户得到所有的借款后能在有限的时间内归还。

用银行家算法分配资源时，测试进程对资源的最大需求量，若现存资源能满足最大需求就满足当前进程的申请，否则推迟分配，这样能够保证至少有一个进程可以得到所需的全部资源而执行到结束，然后归还资源，若OS能保证所有进程在有限的时间内得到所需资源则称系统处于安全状态。

设计报告撰写格式要求：

1设计题目与要求2设计思想

3系统结构4数据结构的说明和模块的算法流程图

5使用说明书（即用户手册）：

内容包含如何登录、退出、读、写等操作说明

6运行结果和结果分析（其中包括实验的检查结果、程序的运行情况）

7自我评价与总结8附录：

程序清单，注意加注释（包括关键字、方法、变量等），在每个模块前加注释；

时间安排

7月4日布置课程设计任务；分配题目后，查阅资料、准备程序；

7月5～7月7日上机调试程序、书写课程设计报告；

7月8日提交课程设计报告及相关文档。

指导教师签名：

2011年7月2日

系主任签名：

2011年7月3日

摘要1

1绪论4

1.1前言5

2需求分析4

2.1题目描述5

2.2银行家算法5

2.3基本要求5

2.4目的5

3概要设计4

3.1基本思路5

3.2银行家算法步骤5

3.3安全型算法步骤5

3.4数据结构5

3.4.1主要用到的数据结构6

3.4.2程序模块6

4详细设计4

4.1主要函数的核心代码5

4.1程序流程图5

5测试4

5.1测试结果分析和截图5

6总结4

参考文献4

附录：

原程序清单4

1.前言

为了提高资源利用率,应采用动态分配资源的方法。

但是，为了避免可能产生的死锁，在进行资源分配时，应采用某种算法来预测是否有可能发生死锁，若存在可能性，就拒绝企图获得资源的请求。

预防死锁和避免死锁的不同在于，前者所采用的分配策略本身就否定了必要条件之一，这样就保证死锁不可能发生；而后者是在动态分配资源的策略下采用某种算法来预防可能发生的死锁，从而拒绝可能引起死锁的其个资源请求，银行家算法是避免死锁的一种重要方法。

银行家算法的基本思想是分配资源之前,判断系统是否是安全的;若是,才分配。

它是最具有代表性的避免死锁的算法。

2.算法的原理

银行家算法是一种最有代表性的避免死锁的算法。

要解释银行家算法，必须先解释操作系统安全状态和不安全状态。

安全状态：

如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。

安全状态一定是没有死锁发生。

不安全状态:

不存在一个安全序列。

不安全状态不一定导致死锁。

那么什么是安全序列呢？

安全序列：

一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi（1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj（j

操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。

当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。

若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。

3．算法的实现

3.1初始化

由用户输入数据，分别对可利用资源向量矩阵AVAILABLE、最大需求矩阵MAX、分配矩阵ALLOCATION、需求矩阵NEED赋值。

3.2算法思想

在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。

在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。

银行家算法的基本思想是分配资源之前,判断系统是否是安全的;若是,才分配。

它是最具有代表性的避免死锁的算法。

设进程cusneed提出请求REQUEST[i]，则银行家算法按如下规则进行判断。

（1）如果REQUEST[cusneed][i]<=NEED[cusneed][i]，则转

（2）；否则出错。

（2）如果REQUEST[cusneed][i]<=AVAILABLE[cusneed][i]，则转（3）；否则出错。

（3）系统试探分配资源，修改相关数据：

AVAILABLE[i]-=REQUEST[cusneed][i];

ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];

NEED[cusneed][i]-=REQUEST[cusneed][i];

（4）系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。

3．2银行家算法步骤

（1）如果Requesti＜or=Need,则转向步骤

（2）；否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。

（2）如果Request＜or=Available,则转向步骤（3）；否则，表示系统中尚无足够的资源，进程必须等待。

（3）系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值：

    Available=Available-Request[i];

    Allocation=Allocation+Request;

    Need=Need-Request;

（4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

3．3安全性算法步骤

（1）设置两个向量

①工作向量Work。

它表示系统可提供进程继续运行所需要的各类资源数目，执行安全算法开始时，Work=Allocation;

②布尔向量Finish。

它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]=false，当有足够资源分配给进程时，令Finish[i]=true。

（2）从进程集合中找到一个能满足下述条件的进程：

①Finish[i]=false

②Need

如找到，执行步骤（3）；否则，执行步骤（4）。

（3）当进程P获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：

Work=Work+Allocation;

Finish[i]=true;

转向步骤

（2）。

（4）如果所有进程的Finish[i]=true,则表示系统处于安全状态；否则，系统处于不安全状态。

3.3程序流程图

3.4安全性检查算法

（1）设置两个工作向量Work=AVAILABLE;FINISH

（2）从进程集合中找到一个满足下述条件的进程，

FINISH==false;

NEED<=Work;

如找到，执行（3）；否则，执行（4）

（3）设进程获得资源，可顺利执行，直至完成，从而释放资源。

Work+=ALLOCATION;

Finish=true;

GOTO2

（4）如所有的进程Finish=true，则表示安全；否则系统不安全。

3.5定义全局变量

intAvailable[x];//各种资源可利用的数量

intAllocation[y][y];//各进程当前已分配的资源数量

intMax[y][y];//各进程对各类资源的最大需求数

intNeed[y][y];//还需求矩阵

intRequest[x];//申请各类资源的数量

intWork[x];//工作向量，表系统可提供给进程运行所需各类资源数量

intFinish[y];//表系统是否有足够的资源分配给进程，0为否，1为是

4.程序测试截图

5.设计体会

经过几天的自己动手练习，对操作系统的掌握又进了一步，收获了很多课堂上和书上未出现过的或老师未讲到的一些知识。

在完成实验的过程中，进行了反复的修改和调试，这次实验，让我基本上明白了银行家算法的基本原理，加深了对课堂上知识的理解，也懂得了如何让银行家算法实现，但编程功底的原因使程序很是繁琐。

这次的设计数据是通过一道实际的题目来体现银行家算法避免死锁的问题，先用银行家算法给其中一个进程分配资源，看它所请求的资源是否大于它的需求量，才和系统所能给的资源相比较.让进程形成一个安全队列,看系统是否安全.再利用安全性算法检查此时系统是否安全。

要做一个课程设计，如果知识面只是停留在书本上，是不可能把课成设计完全地做好。

用VC++6.0编程，感觉自己有点力不从心，很多C语言的知识都忘了，只好翻出以前的C语言课本和数据结构来复习。

每次的课程设计中都能将以前的知识顺便再复习一遍，课程设计是给了我们一个机会去动手和主动复习，同时也是提醒我们应该注重平时的积累。

从课程设计以后还是要多多的动手，在实践中体会理论知识，这样才不会在要做实验和设计时，觉得无从下手。

感谢赵老师一周的幸苦指导。

参考文献

[1]庞丽萍.《操作系统原理》[M].武汉：

华中科技大学出版社，2008

[2]杨树青,王欢.《Linux环境下C编程指南》[M].北京：

清华大学出版社，2007

[3]陈维兴,林小茶.《C++面对对象程序设计教程》[M].北京：

清华大学出版社，2004

[4]杨路明.《C语言程序设计教程》[M].北京：

北京邮电大学出版社，2005

附录：

源程序清单

#include

#include

structtype

{

inta;

intb;

intc;

};

structallocation

{

structtypevalue;

structallocation*next;

};

structmax

{

structtypevalue;

structmax*next;

};

structavailable

{

structtypevalue;

structavailable*next;

};

structneed

{

structtypevalue;

structneed*next;

};

structpath

{

intvalue;

structpath*next;

};

structfinish

{

intvalue;

structfinish*next;

};

voidmain（）

{

intp,status=0,i,j,temp,flag=0;

structallocation*allochead,*alloc1,*alloc2,*alloctemp;

structmax*maxhead,*max1,*max2,*maxtemp;

structavailable*availablehead,*workhead,*worktemp;

structneed*needhead,*need1,*need2,*needtemp;

structpath*pathhead,*path1,*path2,*pathtemp;

structfinish*finishhead,*finish1,*finish2,*finishtemp;

printf（"请输入进程的数目\n"）;

scanf（"%d",&p）;

for（i=0;i

{

printf（"\n输入进程p%d已经分配的资源\n",i+1）;

if（flag==0）

{

allochead=alloc1=alloc2=（structallocation*）malloc（sizeof（structallocation））;

printf（"\t当前资源类型是%c\t",'a'）;

scanf（"%d",&alloc1->value.a）;

printf（"\t当前资源类型是%c\t",'b'）;

scanf（"%d",&alloc1->value.b）;

printf（"\t当前资源类型是%c\t",'c'）;

scanf（"%d",&alloc1->value.c）;

flag++;

allochead=alloc1;

}

else

{

alloc2=（structallocation*）malloc（sizeof（structallocation））;

printf（"\t当前资源类型是%c\t",'a'）;

scanf（"%d",&alloc2->value.a）;

printf（"\t当前资源类型是%c\t",'b'）;

scanf（"%d",&alloc2->value.b）;

printf（"\t当前资源类型是%c\t",'c'）;

scanf（"%d",&alloc2->value.c）;

alloc1->next=alloc2;

alloc1=alloc2;

flag++;

}

}

alloc2->next=NULL;

flag=0;

for（i=0;i

{

printf（"\n输入进程p%d要求的最大数目\n",i+1）;

if（flag==0）

{

maxhead=max1=max2=（structmax*）malloc（sizeof（structmax））;

printf（"\t当前资源类型是%c\t",'a'）;

scanf（"%d",&max1->value.a）;

printf（"\t当前资源类型是%c\t",'b'）;

scanf（"%d",&max1->value.b）;

printf（"\t当前资源类型是%c\t",'c'）;

scanf（"%d",&max1->value.c）;

maxhead=max1;

flag++;

}

else

{

max2=（structmax*）malloc（sizeof（structmax））;

printf（"\t当前资源类型是%c\t",'a'）;

scanf（"%d",&max2->value.a）;

printf（"\t当前资源类型是%c\t",'b'）;

scanf（"%d",&max2->value.b）;

printf（"\t当前资源类型是%c\t",'c'）;

scanf（"%d",&max2->value.c）;

max1->next=max2;

max1=max2;

flag++;

}

}

max2->next=NULL;

flag=0;

printf（"\n请输入可以利用是资源数目\n"）;

availablehead=workhead=（structavailable*）malloc（sizeof（structavailable））;

printf（"\n"）;

printf（"\t当前资源类型是%c\t",'a'）;

scanf（"%d",&availablehead->value.a）;

printf（"\t当前资源类型是%c\t",'b'）;

scanf（"%d",&availablehead->value.b）;

printf（"\t当前资源类型是%c\t",'c'）;

scanf（"%d",&availablehead->value.c）;

workhead=availablehead;

workhead->value=availablehead->value;

flag=0;

alloctemp=allochead;

maxtemp=maxhead;

for（i=0;i

{

if（flag==0）

{

needhead=need1=need2=（structneed*）malloc（sizeof（structneed））;

need1->next=need2->next=NULL;

need1->value.a=（maxtemp->value.a）-（alloctemp->value.a）;

need1->value.b=（maxtemp->value.b）-（alloctemp->value.b）;

need1->value.c=（maxtemp->value.c）-（alloctemp->value.c）;

needhead=need1;

flag++;

}

else

{

need2=（structneed*）malloc（sizeof（structneed））;

need2->value.a=（maxtemp->value.a）-（alloctemp->value.a）;

need2->value.b=（maxtemp->value.b）-（alloctemp->value.b）;

need2->value.c=（maxtemp->value.c）-（alloctemp->value.c）;

need1->next=need2;

need1=need2;

flag++;

}

maxtemp=maxtemp->next;

alloctemp=alloctemp->next;

}

need2->next=NULL;

flag=0;

for（i=0;i

{

if（flag==0）

{

finishhead=finish1=finish2=（structfinish*）malloc（sizeof（structfinish））;

finish1->next=finish2->next=NULL;

finish1->value=0;

finishhead=finish1;

flag++;

}

else

{

finish2=（structfinish*）malloc（sizeof（structfinish））;

finish2->value=0;

finish1->next=finish2;

finish1=finish2;

flag++;

}

}

finish2->next=NULL;

flag=0;

for（temp=0;temp

{

alloctemp=allochead;

needtemp=needhead;

finishtemp=finishhead;

worktemp=workhead;

for（j=0;j

{

if（finishtemp->value==0）

{

if（（needtemp->value.a<=worktemp->value.a）&&（needtemp->value.b<=worktemp->value.b）&&（needtemp->value.c<=worktemp->value.c））

{

worktemp->value.a+=alloctemp->value.a;

worktemp->value.b+=alloctemp->value.b;

worktemp->value.c+=alloctemp->value.c;

finishtemp->value=1;

if（flag==0）

{

pathhead=path1=path2=（structpath*）malloc（sizeof（structpath））;

path1->next=path2->next=NULL;

path1->value=j+1;

pathhead=path1;

flag++;

}

else

{

path2=（structpath*）malloc（sizeof（structpath））;

path2->value=j+1;

path1->next=path2;

path1=path2;

flag++;

}

finishtemp=finishtemp->next;

alloctemp=alloctemp->next;

needtemp=needtemp->next;

}

else

{

finishtemp=finishtemp->next;

alloctemp=alloctemp->next;

needtemp=needtemp->next;

}

}

else

{

finishtemp=finishtemp->next;

alloctemp=alloctemp->next;

needtemp=needtemp->next;

}

}

}

path2->next=NULL;

finishtemp=finishhead;

pathtemp=pathhead;

for（temp=0;temp

{

if（finishtemp->value==0）

{

printf（"\n警告!

当前系统是不安全的\n"）;

exit（0）;

}

finishtemp=finishtemp->next;

}

printf（"\n当前系统是安全的!

\n"）;

printf（"\n安全序列为:

\n"）;

for（i=0;i

{

printf（"p%d\t",pathhead->value）;

pathhead=pathhead->next;

}

}

设计过程中质疑（或答辩）记载：

1.银行家算法的主要问题是什么？

答：

要求每个进程必须事先知道资源的最大需求量，而且，在系统运行过程中，考查每个进程对各类资源的申请需花费较多的时间。

2.银行家算法的主要思想是什么？

答：

一个进程进入系统时分配资源之前,判断系统是否是安全的，即看它所请求的资源是否大于它的最大需求量，若正常,则判断该进程所需剩余剩余量（包括本次申请）是否超出系统所掌握的剩余资源量,若不超出,则分配,否则等待。

指导教师评语：

签名：

年月日