编程序模拟银行家算法范本模板Word格式.docx
《编程序模拟银行家算法范本模板Word格式.docx》由会员分享，可在线阅读，更多相关《编程序模拟银行家算法范本模板Word格式.docx（18页珍藏版）》请在冰豆网上搜索。
7自我评价与总结
8附录：
程序清单,注意加注释（包括关键字、方法、变量等），在每个模块前加注释；
三、课程设计步骤及时间进度和场地安排
本课程设计将安排在第17周，教育技术中心。
具体安排如下:
第一天，下发任务书，学生查阅资料
第二天，系统设计和原型开发
第三,四天系统功能实现
第五天，系统调试测试打包和验收
周次
星期一
星期二
星期三
星期四
星期五
第17周
第1-8节
第1—8节
地点
现教241
四、课程设计考核及评分标准
课程设计考核将综合考虑学生考勤和参与度，系统设计方案正确性，系统设计和开发效果以及课程设计报告书的质量。
具体评分标准如下：
设置六个评分点
（1）设计方案正确，具有可行性、创新性；
25分
（2）系统开发效果较好；
（3）态度认真、刻苦钻研、遵守纪律;
10分
（4）设计报告规范、课程设计报告质量高、参考文献充分20分
（5）课程设计答辩概念清晰，内容正确10分
（6）课程设计期间的课堂考勤、答疑与统筹考虑。
按上述六项分别记分后求和，总分按五级记分法记载最后成绩。
优秀（100～90分）,良好（80～89分），中等（70～79分），及格（60~69分），
不及格（0～59分）
1设计题目与要求
1。
1设计题目
1.2实验要求
本实验要求用用c/c++语言在Linux操作系统环境下编写和调试一个简单的银行家算法程序。
2设计思想
将一定数量的资金供多个用户周转使用，当用户对资金的最大申请量不现存资金时可接纳一个新客户，客户可以分期借款,但借款总数不能超过最大的申请量。
银行家对客户的借款可以推迟支付，但是能够使客户在有限的时间内得到借款，客户得到所有的借款后能在有限的时间内归还。
用银行家算法分配资源时，测试进程对资源的最大需求量,若现存资源能满足最大需求就满足当前进程的申请，否则推迟分配,这样能够保证至少有一个进程可以得到所需的全部资源而执行到结束,然后归还资源，若OS能保证所有进程在有限的时间内得到所需资源则称系统处于安全状态。
3．实验环境
系统平台:
LINUX
开发语言:
C
开发工具：
PC机一台
4数据结构的说明和模块的算法流程图
4。
1死锁避免:
定义：
：
系统设计时确定资源分配算法，保证不发生死锁。
具体的做法是破坏产生死锁的四个必要条件之一
1.1破坏“不可剥夺”条件
在允许进程动态申请资源前提下规定,一个进程在申请新的资源不能立即得到满足而变为等待状态之前,必须释放已占有的全部资源，若需要再重新申请
2破坏“请求和保持”条件
要求每个进程在运行前必须一次性申请它所要求的所有资源,且仅当该进程所要资源均可满足时才给予一次性分配
4.1.3破坏“循环等待”条件
采用资源有序分配法：
把系统中所有资源编号,进程在申请资源时必须严格按资源编号的递增次、序进行，否则操作系统不予分配.
2安全状态与不安全状态
安全状态:
如果存在一个由系统中所有进程构成的安全序列P1，…Pn，则系统处于安全状态.一个进程序列{P1，…，Pn}是安全的,如果对于每一个进程Pi（1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj（j〈i）当前占有资源量之和，系统处于安全状态（安全状态一定是没有死锁发生的）
不安全状态：
不存在一个安全序列，不安全状态一定导致死锁。
3数据结构：
（1）可利用资源向量Available
是个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。
如果Available［j]=K，则表示系统中现有Rj类资源K个.
（2）最大需求矩阵Max
这是一个n×
m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
如果Max［i，j]=K，则表示进程i需要Rj类资源的最大数目为K。
（3）分配矩阵Allocation
这也是一个n×
m的矩阵,它定义了系统中每一类资源当前已分配给每一进程的资源数.如果Allocation[i,j］=K,则表示进程i当前已分得Rj类资源的数目为K。
（4）需求矩阵Need。
m的矩阵，用以表示每一个进程尚需的各类资源数。
如果Need[i,j]=K，则表示进程i还需要Rj类资源K个，方能完成其任务.
Need[i,j］=Max［i，j]-Allocation[i,j］
4安全性检查算法
4.4。
1设置两个工作向量Work=AVAILABLE；
FINISH
2从进程集合中找到一个满足下述条件的进程，
FINISH==false；
NEED<
=Work；
如找到，执行（3）；
否则，执行（4）
4.4.3设进程获得资源，可顺利执行，直至完成，从而释放资源.
Work+=ALLOCATION;
Finish=true；
GOTO2
4.4.4如所有的进程Finish=true，则表示安全;
否则系统不安全.
4.5程序流程图
5使用说明书
5.1首先在终端中使用vi编辑器建立c的源文件
5。
2然后使用gcc编辑器编译生成可执行文件
5.3使用命令。
/当前名字，来执行
6运行结果和结果分析
6.1输入
6。
2输出
3结果分析
这次的设计数据是通过一道实际的题目来体现银行家算法避免死锁的问题，先用银行家算法给其中一个进程分配资源,看它所请求的资源是否大于它的需求量,才和系统所能给的资源相比较。
让进程形成一个安全队列，看系统是否安全.再利用安全性算法检查此时系统是否安全。
7自我评价与总结
在本次实验中我们使用了liunx变成环境,让我们更加系统深入的了解了liunx，gcc编程思路和思想，同时让我更加深刻的了解银行家算法,了解死锁的避免和预防，对操作系统对资源的申请和释放有了更加深刻的理解，同时在编程过程中积极的向老师同学请教问题与他们一起探讨在系统中存在的问题和漏洞。
深入了解了银行家算法的资源申请和资源分配的过程及原则。
保证系统处于安全状态。
经过本周的课程设计，我对操作系统的掌握又进了一步，收获了很多知识。
，终于我了由于对c语言不够熟练，在试验过程中,进行了反复的修改和调试，解银行家算法的基本原理,并且在此次的课程设计中我又复习了一下c语言，加深了对它的了解，而且在课程设计的过程中我们同样学会了如何简单的操作与使用Linux操作系统，学习到了许多Linux操作系统中常用的一些密令.这次的设计数据是通过一道实际的题目来体现银行家算法避免死锁的问题,先用银行家算法给其中一个进程分配资源，看它所请求的资源是否大于它的需求量，才和系统所能给的资源相比较。
让进程形成一个安全队列看系统是否安全.再利用安全性算法检查此时系统是否安全。
操作系统的基本特征是并发与共享。
系统允许多个进程并发执行,并且共享系统的软、硬件资源。
为了最大限度的利用计算机系统的资源,操作系统应采用动态分配的策略,但是这样就容易因资源不足，分配不当而引起“死锁”.而我本次课程设计就是得用银行家算法来避免“死锁”。
银行家算法就是一个分配资源的过程，使分配的序列不会产生死锁.此算法的中心思想是：
按该法分配资源时，每次分配后总存在着一个进程,如果让它单独运行下去，必然可以获得它所需要的全部资源，也就是说，它能结束，而它结束后可以归还这类资源以满足其他申请者的需要。
通过这次实验，我体会到银行家算法的重要性，银行家算法是避免死锁的主要方法，其思路在很多方面都非常值得我来学习借鉴.通过这次实践,我知道，要做一个课程设计，如果知识面只是停留在书本上,是不可能把课成设计完全地做好.
在课程设计中，很多C语言的知识都忘了，每次的课程设计中都能将以前的知识顺便再复习一遍,课程设计是给了我们一个机会去动手和主动复习,同时也是提醒我们应该注重平时的积累。
从课程设计以后还是要多多的动手，在实践中体会理论知识，才能吸取经验教训。
经过这次实验训练,我对这门课程有了更好的了解。
8附录：
源程序清单
＃include〈iostream.h>
#include〈string。
h〉
＃include<
stdio。
h>
#defineFalse0
#defineTrue1
intMax[100][100]={0｝;
//各进程所需各类资源的最大需求
intAvaliable［100]=｛0｝；
//系统可用资源
charname[100]={0｝；
//资源的名称
intAllocation［100］［100]={0｝；
//系统已分配资源
intNeed[100］［100］=｛0｝；
//还需要资源
intRequest［100]={0}；
//请求资源向量
inttemp［100］={0｝;
//存放安全序列
intWork［100]=｛0｝；
//存放系统可提供资源
intp［100]={0}；
intq[100]［100]=｛0}；
intz［100］[100］=｛0};
intM=100；
//作业的最大数为100
intN=100；
//资源的最大数为100
intgg=1;
voidshowdata（）//显示资源矩阵
{
inti,j；
cout〈〈endl〈<
"
此时刻的资源分配情况为：
〈〈endl;
cout<
〈"
MaxAllocationNeedAvaliable"
<
endl;
进程名”;
for（j=0;
j〈4;
j++）{
for（i=0；
i〈N；
i++）
name[i］<
〈”"
;
cout〈<
””;
}
for（i=0;
i〈M；
i++）{
"
〈〈i<
”"
for（j=0；
j〈N；
j++）
〈Max[i］［j]〈<
”；
j<
N;
Allocation[i］［j］〈〈"
cout〈〈”"
；
Need[i］［j］<
if（i==0）｛
for（j=0;
j〈N;
Avaliable［j]<
//输出分配资源
}
cout〈〈endl；
intchangdata（inti）//进行资源分配
{
intj;
for（j=0;
M；
j++）｛//p[j]=Avaliable［j］；
Avaliable［j］=Avaliable［j］—Request[j］;
//q[i］［j]=Allocation［i][j］;
Allocation［i]［j]=Allocation[i]［j］+Request[j]；
//z[i］［j］=Need[i]［j］；
Need[i]［j]=Need［i][j］-Request［j］;
return1;
｝
intsafe（）//安全性算法
｛
inti，d，k=0，m,h，s,apply，Finish[100]=｛0｝；
intj；
intflag=0；
for（i=0；
i〈N;
Work［i]=Avaliable［i];
cout<
endl<
”安全性检查”〈〈endl;
”WorkNeedAllocationWork+AllocationFinish"
〈endl；
”进程名"
for（h=0；
h〈4;
h++）{
for（s=0；
s〈N；
s++）
〈name［s］〈<
｝
endl；
i〈M;
i++）{
apply=0;
j++）｛
if（Finish[i］==False&
＆Need［i][j]〈=Work[j］）
{
apply++；
if（apply==N）
｛cout〈<
〈<
i〈<
”;
for（d=0；
d〈N;
d++）
cout<
Work［d]<
〈””；
for（d=0;
d<
cout〈<
Need［i][d]<
d〈N；
〈Allocation[i]［d]<
cout〈〈””;
for（m=0;
m〈N;
m++）
｛
Work[m］=Work［m]+Allocation［i][m]；
〈Work［m]〈〈””；
}//变分配数
Finish[i］=True；
temp［k］=i;
true”<
i=—1;
k++；
flag++；
for（i=0;
if（Finish［i]==False）{
Avaliable[j］=Avaliable［j]+Request[j］;
Allocation[i][j]=Allocation［i］［j]-Request［j]；
Need[i］［j]=Need[i]［j]+Request［j]；
endl〈<
系统进入不安全状态！
此时系统不分配资源!
”<
//不成功系统不安全
return0；
”此时系统是安全的！
//如果安全，输出成功
cout〈〈"
安全序列为：
”;
i<
M;
i++）{//输出运行进程数组
〈temp［i］；
if（i<
M-1）cout<
〈”->
voidshare（）//利用银行家算法对申请资源对进行判定
charch；
inti=0,j=0；
ch='
y’；
〈endl〈<
”请输入要求分配的资源进程号（0-"
M—1<
）：
cin>
>
i;
//输入须申请的资源号
”请输入进程"
申请的资源:
for（j=0；
〈name［j］<
cin〉〉Request［j］;
//输入需要申请的资源
N；
if（Request[j］〉Need［i］[j］）//判断申请是否大于需求,若大于则出错
endl〈〈”进程"
”申请的资源大于它需要的资源"
分配不合理，不予分配！
”〈<
ch='
n’；
break;
else｛
if（Request[j］>
Avaliable［j］）//判断申请是否大于当前资源,若大于则
{//出错
”进程”<
申请的资源大于系统现在可利用的资源"
cout〈〈”分配出错，不予分配！
ch=’n'
break；
if（ch=='
y’）{
changdata（i）;
//根据进程需求量变换资源
showdata（）；
//根据进程需求量显示变换后的资源
safe（）;
//根据进程需求量进行银行家算法判断
intmain（）//主函数
intt=1,i,j,number,choice，m，n，flag；
charming；
**＊*＊＊*****＊＊**＊*银行家算法的设计与实现＊****＊**＊****＊*＊*"
请首先输入系统可供资源种类的数量：
cin〉〉n;
N=n；
i〈n;
资源”<
i+1<
”的名称：
cin〉>
ming;
name[i]=ming;
〈”资源的数量：
”；
〉number;
Avaliable[i]=number；
cout〈〈endl；
请输入作业的数量：
cin〉>
m;
M=m;
〈endl<
”请输入各进程的最大需求量（"
〈m<
〈”*"
n〈<
”矩阵）［Max]：
j〈n；
〉Max［i］［j]；
do｛
flag=0；
请输入各进程已经申请的资源量（"
*”〈〈n<
矩阵）［Allocation］:
”〈〈endl；
i〈m；
n；
Allocation［i][j］;
if（Allocation[i］［j］>
Max［i][j]）
flag=1；
Need[i］［j］=Max［i]［j]—Allocation［i］［j］；
if（flag）
申请的资源大于最大需求量，请重新输入！
\n”<
while（flag）；
//显示各种资源
//用银行家算法判定系统是否安全
while
（1）{
if（t==1）｛
”利用银行家算法预分配资源"
share（）；
t=0；
elsebreak；
是否继续银行家算法？
（按1键继续,按其它任意键退出）：
cin〉〉t；
return1;
设计过程中质疑（或答辩）记载：
1.银行家算法的主要思想是什么？
答：
一个进程进入系统时分配资源之前,判断系统是否是安全的，即看它所求
的资源是否大于它的最大需求量，若正常，则判断该进程所需剩余剩余量（包括本次申请）是否超出系统所掌握的剩余资源量,若不超出，
则分配，否则等待。
2。
银行家算法的主要问题是什么？
要求每个进程必须事先知道资源的最大需求量，而且，在系统运行过程中,考查每个进程对各类资源的申请需花费较多的时间.
3.在银行家算法中各个资源存在什么关系？
答:
该进程所需要的资源数NEED［m］[n］=MAX［m］［n]（该进程所需要的最多的资源数）-----ALLOCATION［m］[n］（该进程所占有的资源数）
指导教师评语:
签名:
2014年6月13日
升级会员 