银行家算法课设.docx
《银行家算法课设.docx》由会员分享,可在线阅读,更多相关《银行家算法课设.docx(14页珍藏版)》请在冰豆网上搜索。
银行家算法课设
操作系统实验报告
(理工类)
课程名称:
银行家算法 专业班级:
计算机科学与技术统2
学生学号:
40学生姓名:
林荣
所属院部:
计算机工程学院 指导教师:
李莉
2015——2016 学年 第1学期
金陵科技学院教务处制ﻬ银行家算法
一、 背景知识
在系统运行过程中,对进程发出得每一个系统能够满足得资源申请进行动态检查,并根据检查结果决定就是否分配资源,若分配后系统可能发生死锁,则不予分配,否则予以分配。
在分配资源时判断就是否会出现死锁,如不会死锁,则分配资源。
死锁检测算法保存资源得请求与分配信息,利用某种算法对这些信息加以检查,以判断就是否存在死锁。
主要就是检查就是否有循环等待、
1系统安全状态
1)安全状态
所谓系统就是安全得,就是指系统中得所有进程能够按照某一种次序分配资源,并且依次地运行完毕,这种进程序列{ P1,P2…Pn}就就是安全序列。
如果存在这样一个安全序列,则系统就是安全得。
2)安全状态之例
进程
最大需求
已分配
可用
P1
P2
P3
10
4
9
5
2
2
3
安全序列:
P2→P1→ P3
不安全序列:
P1→…
P3→…
P2→P3→P1
3)由安全状态向不安全状态得转换
2利用银行家算法避免死锁
1)银行家算法中得数据结构
①可利用资源向量Available。
② 最大需求矩阵Max。
③分配矩阵Allocation
④需求矩阵Need
2)银行家算法
①一个银行家拥有一定数量得资金,有若干个客户要贷款,每个客户须在一开始就声明她所需贷款得总额,若该客户贷款总额不超过银行家得资金总额,银行家可以接受客户得要求。
客户贷款就是以每次一个资金单位(如1万RMB等)得方式进行得,客户在借满所需得全部单位款额之前可能会等待,但银行家须保证这种等待就是有限得,可完成得。
②安全性算法
利用安全性算法进行检查,如果分配就是安全得,则执行分配;否则,分配不安全,不予分配。
具体地,
1) 当进程pi提出资源申请时,按照银行家算法分配资源,系统执行下列步骤:
(1)若Request≤Need,转
(2);否则错误返回ﻫ
(2)若Request≤Available,转(3);否则进程等待ﻫ(3)假设系统分配了资源,则有:
ﻫAvailable:
=Available-Request;ﻫ Allocation:
=Allocation+Request;
Need:
=Need-Request
2)若系统新状态就是安全得,则分配完成,若系统新状态就是不安全得,则恢复原状态,进程等待为进行安全性检查,定义数据结构:
Work:
ARRAY[1、、m]ofinteger;
Finish:
ARRAY[1、、n]ofBoolean;ﻫ安全性检查得步骤:
(1)Work:
=Available;ﻫ Finish:
=false;ﻫ
(2) 寻找满足条件得i:
ﻫa、Finish=false;
b、Need≤Work;ﻫ 如果不存在,则转(4)ﻫ(3)Work:
=Work+Allocation;
Finish:
=true;转
(2)ﻫ(4)若对所有i,Finish=true,则系统处于安全状态,否则处于不安全状态。
二、实验目得
通过模拟实现银行家算法,深入理解死锁避免得意义。
三、实验要求
1充分理解死锁避免得意义。
2理解银行家算法与安全性检查算法得实质
3编写银行家算法模拟程序,实现银行家算法原理。
开始
输入资源数m及各类资源总数,初始化
输入进程数n
i<=n
输入进程i得最大需求向量
Max<=资源总数
提示错误
i加1
初始化need
Need矩阵为0
所有进程运行
结束
任选一个进程作为当前进程
Need向量为0
该进程已运行
输入该进程得资源请求量
调用银行家算法,及安全性算法,完成分配并给出提示
Y
N
N
Y
Y
Y
N
N
四、实验步骤
1.主要函数清单
void showdata()//显示资源矩阵
intchangdata(int i)//进行资源分配
intsafe()//安全性算法
voidshare()//利用银行家算法对申请资源对进行判定
void addprocess()//添加作业
2、算法描述
设Request[i]就是进程Pi得请求向量,如果Requesti[j]=K,表示进程Pi需要K个Rj类型得资源,当Pi发出资源请求后,系统按下面步骤进行检查:
(1)如果Requesti[j]<=Need[i,j],便转向步骤2;否则认为出错,因为它所需要得资源数已超过它所宣布得最大值。
(2)如果Requesti[j]<=Available[j],便转向步骤3;否则,表示尚无足够资源,Pi须等待。
(3)系统试探着把资源分配给进程Pi,并修改下面数据结构中得数值:
Available[j]:
=Available[j]-Requesti[j];
Allocation[i,j]:
=Allocation[i,j]+Requesti[j];
Need[i,j]:
=Need[i,j]-Requesti[j];
(4)系统执行安全性算法,检查此次资源分配后,系统就是否处于安全状态。
若安全,才正式将资源分配给进程Pi,以完成本次分配;否则,将本次得试探分配作废,恢复原来得资源分配状态,让进程Pi等待。
3、数据结构
银行家算法中得数据结构:
(1)可利用资源向量Available。
这就是一个含有n个元素得数组,其中得每一个元素代表一类可利用得资源数目,其初始值就是系统中所配置得该类全部可用资源得数目,其数值随该类资源得分配与回收而动态地改变。
如果Available[j]=K,则表示系统中现有Rj类资源K个。
(2)最大需求矩阵Max。
这就是一个m*n得矩阵,它定义了系统中n个进程中每一个进程对m类资源得最大需求。
如果Max[i,j]=K,则表示进程i需要Rj类资源得最大数目为K。
(3)分配矩阵Allocation。
这也就是一个m*n得矩阵,它定义了系统中每一类资源当前已分配给每一进程得资源数。
如果Allocation[i,j]=K,则表示进程i当前已分得Rj类资源得数目为K。
(4)需求矩阵Need。
这也就是一个n*m得矩阵,用以表示每一个进程尚需得各类资源数。
如果Need[i,j]=K,则表示进程i还需要Rj类资源K个,方能完成其任务。
(5)工作数组Work、。
这就是一个含有n个元素得数组,它代表可以提供分配得资源数,初始值就是Available中得数值,随着资源得回收,它得值也会改变,公式就是Work[i]=Work[i]+Allocation[i]。
五、程序代码
#include<iostream>
usingnamespacestd;
#include
#include<stdio、h>
#defineFalse0
#defineTrue 1
intMax[100][100]={0};//各进程所需各类资源得最大需求
intAvaliable[100]={0};//系统可用资源
char name[100]={0};//资源得名称
intAllocation[100][100]={0};//系统已分配资源
intNeed[100][100]={0};//还需要资源
int Request[100]={0};//请求资源向量
inttemp[100]={0};//存放安全序列
int Work[100]={0};//存放系统可提供资源
intM=100;//作业得最大数为100
intN=100;//资源得最大数为100
voidshowdata()//显示资源矩阵
{
ﻩinti,j;
ﻩcout<<"系统目前可用得资源[Avaliable]:
"<<endl;
ﻩfor(i=0;i<N;i++)cout<ﻩcout<<endl;
for(j=0;jcout<cout<<endl;
ﻩcout<<"Max AllocationNeed"<cout<<"进程名";
ﻩfor(j=0;j<3;j++)
ﻩ{
ﻩfor(i=0;i<N;i++)
cout<<name[i]<<" ";
ﻩcout<<"";
ﻩ}
ﻩcout<<endl;
for(i=0;i{
cout<<""<<i<<"";
ﻩfor(j=0;jﻩﻩﻩcout<cout<<" ";
ﻩfor(j=0;jcout<<Allocation[i][j]<<"";
ﻩcout<<"";
for(j=0;jcout<cout<ﻩ}
}
intchangdata(inti)//进行资源分配
{
ﻩintj;
for(j=0;j{
ﻩﻩAvaliable[j]=Avaliable[j]-Request[j];
ﻩAllocation[i][j]=Allocation[i][j]+Request[j];
ﻩNeed[i][j]=Need[i][j]-Request[j];
ﻩ}
return 1;
}
intsafe()//安全性算法
{
ﻩint i,k=0,m,apply,Finish[100]={0};
int j;
ﻩintflag=0;
Work[0]=Avaliable[0];
ﻩWork[1]=Avaliable[1];
ﻩWork[2]=Avaliable[2];
for(i=0;i<M;i++)
{
ﻩﻩapply=0;
ﻩfor(j=0;jﻩ{
ﻩﻩif (Finish[i]==False&&Need[i][j]<=Work[j])
ﻩﻩ{
ﻩﻩapply++;
ﻩﻩif(apply==N)
ﻩﻩﻩ{
ﻩﻩﻩfor(m=0;m<N;m++)
ﻩWork[m]=Work[m]+Allocation[i][m];//变分配数
ﻩﻩﻩﻩFinish[i]=True;
ﻩﻩﻩﻩtemp[k]=i;i=-1;
ﻩk++;flag++;
ﻩﻩ}
ﻩﻩ}
ﻩﻩ}
}
ﻩfor(i=0;iﻩ{
if(Finish[i]==False)
ﻩﻩ{
ﻩﻩﻩcout<<"系统不安全"<ﻩﻩreturn -1;
ﻩ}
}
ﻩcout<<"系统就是安全得!
"<cout<<"分配得序列:
";
ﻩfor(i=0;i<M;i++)
{
ﻩﻩ//输出运行进程数组
ﻩcout<<temp[i];
if(iﻩcout<<"->";
ﻩ}
cout<ﻩreturn0;
}
voidshare()//利用银行家算法对申请资源对进行判定
{
ﻩcharch;
ﻩinti=0,j=0;
ch='y';
cout<<"请输入要求分配得资源进程号(0-"<";
ﻩcin>>i;//输入须申请得资源号
ﻩcout<<"请输入进程 "<<i<<" 申请得资源:
"<for(j=0;j<N;j++)
{
cout<<name[j]<<":
";
ﻩﻩcin>>Request[j];//输入需要申请得资源
ﻩ}
ﻩfor (j=0;jﻩ{
ﻩif(Request[j]>Need[i][j])//判断申请就是否大于需求,若大于则出错
ﻩ{
ﻩcout<<"进程"<
ﻩﻩcout<<"分配不合理,不予分配!
"<ﻩﻩch='n';
ﻩﻩﻩbreak;
ﻩ}
ﻩelse
ﻩ{
ﻩif(Request[j]>Avaliable[j])//判断申请就是否大于当前资源,若大于则
ﻩﻩﻩ{
ﻩ//出错
ﻩﻩcout<<"进程"<<i<<"申请得资源大于系统现在可利用得资源";
ﻩﻩﻩcout<<"分配出错,不予分配!
"<ﻩﻩch='n';
ﻩﻩﻩbreak;
ﻩﻩﻩ}
ﻩ}
}
if(ch=='y')
{
ﻩﻩchangdata(i);//根据进程需求量变换资源
ﻩﻩshowdata();//根据进程需求量显示变换后得资源
ﻩsafe();//根据进程需求量进行银行家算法判断
}
}
voidaddprocess()
{//添加作业
int flag=M;
M=M+1;
cout<<"请输入该作业得最打需求量[Max]"<for(inti=0;i<N;i++)
{
cout<<name[i]<<":
";
ﻩcin>>Max[flag][i];
ﻩNeed[flag][i]=Max[flag][i]-Allocation[flag][i];
}
ﻩshowdata();
ﻩsafe();
}
intmain()//主函数
{
ﻩinti,j,number,choice,m,n,flag;
charming;
ﻩcout<<"*****************资源管理系统得设计与实现*****************"<<endl;
ﻩcout<<"请首先输入系统可供资源种类得数量:
";
cin>>n;
ﻩN=n;
ﻩfor(i=0;iﻩ{
ﻩﻩcout<<"资源"<
";
ﻩﻩcin>>ming;
name[i]=ming;
ﻩﻩcout<<"资源得数量:
";
cin>>number;
ﻩAvaliable[i]=number;
}
ﻩcout<<endl;
cout<<"请输入作业得数量:
";
cin>>m;
M=m;
cout<<"请输入各进程得最大需求量("<"<<endl;
for(i=0;iﻩfor(j=0;j<n;j++)
ﻩﻩcin>>Max[i][j];
ﻩﻩdo{
ﻩﻩﻩflag=0;
ﻩﻩcout<<"请输入各进程已经申请得资源量("<"<ﻩfor(i=0;iﻩfor(j=0;jﻩﻩ{
ﻩﻩcin>>Allocation[i][j];
ﻩﻩif(Allocation[i][j]>Max[i][j])
ﻩﻩﻩﻩflag=1;
ﻩﻩNeed[i][j]=Max[i][j]-Allocation[i][j];
ﻩﻩ}
ﻩﻩﻩif(flag)
ﻩﻩﻩcout<<"申请得资源大于最大需求量,请重新输入!
\n";
ﻩ}
ﻩﻩwhile(flag);
showdata();//显示各种资源
safe();//用银行家算法判定系统就是否安全
ﻩwhile(true)
ﻩﻩ{
ﻩcout<<"**************银行家算法演示***************"<<endl;
ﻩﻩﻩcout<<"1:
增加资源"<ﻩcout<<"2:
分配资源"<cout<<"*******************************************"<<endl;
ﻩcout<<"请选择功能号:
";
ﻩﻩcin>>choice;
ﻩswitch(choice)
ﻩ{
ﻩﻩcase 1:
addresources();break;
ﻩcase 2:
share();break;
ﻩdefault:
cout<<"请正确选择功能号(0-3)!
"<ﻩ}
ﻩﻩ}
ﻩreturn 1;
}
五.运行结果
6、遇到得问题与解决办法
1.纠结在Linux系统下运行,最后还就是没有搞出来,只能在Windows下运行了。
2.代码得问题,运行时老出现错误,通过上网查询资料解决了。
七、设计体会
经过几天得自己动手练习,对操作系统得掌握又进了一步,收获了很多课堂上与书上未出现过得或老师未讲到得一些知识。
在完成实验得过程中,进行了反复得修改与调试,这次实验,让我基本上明白了银行家算法得基本原理,加深了对课堂上知识得理解,也懂得了如何让银行家算法实现,但编程功底得原因使程序很就是繁琐。
这次得设计数据就是通过一道实际得题目来体现银行家算法避免死锁得问题,先用银行家算法给其中一个进程分配资源,瞧它所请求得资源就是否大于它得需求量,才与系统所能给得资源相比较、让进程形成一个安全队列,瞧系统就是否安全、再利用安全性算法检查此时系统就是否安全。
要做一个课程设计,如果知识面只就是停留在书本上,就是不可能把课程设计完全地做好。
用VC++6、0编程,感觉自己有点力不从心,很多C语言得知识都忘了,只好翻出以前得C语言课本与数据结构来复习。
每次得课程设计中都能将以前得知识顺便再复习一遍,课程设计就是给了我们一个机会去动手与主动复习,同时也就是提醒我们应该注重平时得积累。
从课程设计以后还就是要多多得动手,在实践中体会理论知识,这样才不会在要做实验与设计时,觉得无从下手。
银行家算法就是操作系统中避免死锁得典型算法。
我设计得这个程序中包含了三大块,利用数据结构初始化,银行家算法,安全性算法。
在初始化这一块,程序需要用到可利用资源向量Available[j]、最大需求矩阵Max[i、j]、分配矩阵Allocation[i,j]、需求矩阵Need[i,j]。
它们之间有着一定得联系,Need[i,j]=Max[I,j]-Allocation[i,j],请求资源时需要用到银行家算法,检查资源得分配需要用到安全性算法。
在将三大块结合起来就能很好得避免死锁得发生了。
通过这次得实验,我更进一步得了解了银行家算法,并对数据结构得用法理解得更透彻了,在实验得过程中我深刻得体会到了合作得意义,我遇到了一些困难,通过对书上所学得知识反复得思考与理解与与同学之间得相互讨论,最终将银行家算法真正得理解,并且将它用C++实现。
在以后得学习当中我会更加努力得将这一门课程学好。
这次课程设计时间上虽说仓促点,但就是我依然学到了很多得实用性知识。
除了更深得了解这个算法,而且对C语言进行了复习,而且其过程中有很多得知识点都不记得了。
八、参考文献
[1] 庞丽萍、《操作系统原理》[M]、 武汉:
华中科技大学出版社,2008
[2]杨树青,王欢、《Linux环境下C编程指南》[M]、北京:
清华大学出版社,2007
[3]陈维兴,林小茶、 《C++面对对象程序设计教程》[M]、 北京:
清华大学出版社,2004
[4]杨路明、《C语言程序设计教程》[M]、北京:
北京邮电大学出版社,2005