实验三 银行家调度算法.docx
《实验三 银行家调度算法.docx》由会员分享，可在线阅读，更多相关《实验三 银行家调度算法.docx（13页珍藏版）》请在冰豆网上搜索。
实验三银行家调度算法
实验三银行家调度算法
1．实验目的
（1）使学生加深对死锁的理解，理解预防死锁的思想和方法，使学生明确系统安全状态的概念。
（2）使学生能利用银行家调度算法实现避免死锁。
2．实验预备内容
阅读死锁的基本概念，产生死锁的原因、产生死锁的必要条件以及处理死锁的基本方法，重点阅读关于死锁避免的章节。
3．实验环境
（1）一台运行Windows2000professional操作系统的计算机。
（2）选用turboc、visualc++、delphi、c++builder或visualbasic等任何一种语言，建议用c++。
4．实验时间：
4个机时。
5．实验内容
（1）设置银行家算法中的数据结构
（a）可利用资源向量Available
它是一个含有m个元素的数组，其中的每一个元素代表一类可利用资源的数目，其初始值是系统中所配置该类全部可用资源数目。
其数值随该类资源的分配和回收而动态地改变。
如果Available[j]=k表示系统中现有
类资源k个。
（b）最大需求矩阵Max
这是一个
的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
如果Max（i,j）=k，表示进程i需要
类资源的最大数目为k。
（c）分配矩阵Allocation
这是一个
的矩阵，它定义了系统中每一类资源当前已分配该每一进程的资源数。
如果Allocation（i,j）=k,表示进程i当前已分得
类资源的数目为k。
（d）分配矩阵Need
这是一个
的矩阵，用以表示每一个进程尚需的各类资源数。
如果Need（i,j）=k表示进程i还需要
类资源k个，方能完成其任务。
上述三个矩阵存在如下关系：
Need（i,j）=Max（i,j）-Allocation（i,j）
（2）银行家算法
设
是进程
的请求向量。
如果
[j]=k，表示进程
需要k个
类的资源。
当
发出资源请求后，系统按下述步骤进行检查：
①如果
则转向步骤②；否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。
②如果
，则转向步骤③；否则，表示系统中尚无足够的的资源，
必须等待。
③系统试探把要求的资源分配给进程
，并修改下面数据结构中的数值：
Available
Available-
；
；
；
④系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
若安全，才正式将资源分配给进程
，以完成本次分配；否则，将试探分配作废，恢复原来的资源分配状态，让进程
等待。
（3）安全性算法
系统所执行的安全性算法描述如下：
①设置两个向量
（a）工作向量Work。
它表示系统可提供给进程继续运行所需要的各类资源数目，它含有m个元素，执行安全算法开始时，Work:
=Available。
（b）Finish。
它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]:
=false；当有足够资源分配给进程时，令Finish[i]:
=true。
②从进程集合中找到一个能满足下列条件的进程：
（a）Finish[i]:
=false
（b）
如找到，执行步骤③；否则执行步骤④。
③当进程
获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work:
=Work+Allocationi;
Finish[i]:
=true;
gotostep
（2）
④如果所有进程的Finish[i]:
=true，则表示系统处于安全状态；否则，系统处于不安全状态。
6．参考算法
#include
#include
#include
#include"windows.h"
#defineMAX_PROCESS32 //最大进程数
#defineMAX_COURCE64 //最大资源类别
intMAX_FACT_PROCESS; //实际总进程数
intMAX_FACT_COURCE; //实际资源类别数
intAvailable[MAX_COURCE]; //可利用资源向量
intMax[MAX_PROCESS][MAX_COURCE]; //最大需求矩阵
intAllocation[MAX_PROCESS][MAX_COURCE]; //分配矩阵
intNeed[MAX_PROCESS][MAX_COURCE]; //需求矩阵
intRequest_PROCESS; //发出请求的进程
intRequest_COURCE; //被请求资源类别
intRequest_COURCE_NEMBER; //请求资源数
structCOMP{
intvalue;
intnum;
intnext;
};
intflag=0;
voidRead_Initiate（void）{ //读入初始化文档
ifstreaminfile（"Initiate.txt"）;
if（!
infile）{
cout<<"不能打开输入文件:
"<<"Initiate.txt"<<'\n';
exit
（1）;
}
cout<<"开始读入初始化文档"<<'\n';
intch;
intArray[MAX_PROCESS*MAX_COURCE*2];
intnum=0;
while（infile>>ch）
Array[num++]=ch;
num=0;
MAX_FACT_COURCE=Array[num++];
for（intj=0;jAvailable[j]=Array[num++];
MAX_FACT_PROCESS=Array[num++];
for（inti=0;ifor（intj=0;jMax[i][j]=Array[num++];
}
infile.close（）;
}
voidWrite_Initiate（void）{ //写入初始化文档（分配资源
ofstreamoutfile（"Initiate.txt"）;
if（!
outfile）{
cout<<"不能打开初始化文档：
"<<'\n';
exit
（1）;
}
intArray[MAX_PROCESS*MAX_COURCE*2];
intnum=0;
Array[num++]=MAX_FACT_COURCE;
for（inti=0;iArray[num++]=Available[i];
Array[num++]=MAX_FACT_PROCESS;
for（i=0;ifor（intj=0;jArray[num++]=Max[i][j];
num=0;
outfile<for（i=0;ioutfile<outfile<<'\n'<for（i=0;ifor（intj=0;joutfile<outfile<}
DWORDm_delay=3000;
Sleep（m_delay）;
outfile.close（）;
cout<<"修改初始化文档成功!
"<}
voidAllocated_list（void）{ //读入已分配资源列表
ifstreaminfile（"Allocated_list.txt"）;
if（!
infile）{
cout<<"不能打开输入文件:
"<<"Allocated_list.txt"<<'\n';
exit
（1）;
}
cout<<"开始读入已分配资源列表"<<'\n';
intch,num=0;
intArray[MAX_PROCESS*MAX_COURCE];
while（infile>>ch）
Array[num++]=ch;
num=0;
for（inti=0;ifor（intj=0;jAllocation[i][j]=Array[num++];
infile.close（）;
}
voidSet_Need（void）{ //设置需求矩阵
cout<<"设置需求矩阵"<<'\n';
for（inti=0;ifor（intj=0;jNeed[i][j]=Max[i][j]-Allocation[i][j];
}
voidRead_Request（void）{ //读入请求向量
ifstreaminfile（"Request_list.txt"）;
if（!
infile）{
cout<<"不能打开输入文件:
"<<"Request_list.txt"<<'\n';
exit
（1）;
}
cout<<"开始读入请求向量"<<'\n';
intArray[3];
intnum=0,ch;
while（infile>>ch）
Array[num++]=ch;
Request_PROCESS=Array[0];
Request_COURCE=Array[1];
Request_COURCE_NEMBER=Array[2];
infile.close（）;
}
voidWrite_Allocation（void）{ //修改资源分配列表（资源分配）
ofstreamoutfile（"Allocated_list.txt"）;
if（!
outfile）{
cout<<"不能打开资源分配列表：
"<<'\n';
exit
（1）;
}
for（inti=0;ifor（intj=0;joutfile<outfile<}
DWORDm_delay=3000;
Sleep（m_delay）;
cout<<"修改资源分配列表成功!
"<outfile.close（）;
}
voidAllocate_Source（void）{ //开始分配（已通过扫描和安全性检测）
cout<<'\n'<<"开始给第"<<<"类资源"<Write_Initiate（）;
Write_Allocation（）;
DWORDm_delay=3000;
Sleep（m_delay）;
cout<<'\n'<<"祝贺您，资源分配已成功!
"<}
voidTest_Safty（）{ //安全性检测
cout<<'\n'<<"进入安全性检测!
"< intWork[MAX_COURCE];
for（inti=0;iWork[i]=Available[i];
}
boolFinish[MAX_PROCESS][MAX_COURCE];
for（i=0;ifor（intj=0;jFinish[i][j]=false;
COMPArray[32];
for（i=0;i{
Array[i].value=Need[i][Request_COURCE-1];
Array[i].num=i;
}
for（i=0;ifor（intj=i+1;jif（Array[i].value>=Array[j].value）{
intt;
t=Array[j].value;
Array[j].value=Array[i].value;
Array[i].value=t;
t=Array[j].num;
Array[j].num=Array[i].num;
Array[i].num=t;
}
elsecontinue;
}
DWORDm_delay=3000;
Sleep（m_delay）;
/*for（i=0;ifor（intj=0;jcout<cout<}
*/
if（Finish[Request_PROCESS-1][Request_COURCE-1]==false&&Need[Request_PROCESS-1][Request_COURCE-1]<=Work[Request_COURCE-1]）
{
Work[Request_COURCE-1]=Work[Request_COURCE-1]+Allocation[Request_PROCESS-1][Request_COURCE-1];
Finish[Request_PROCESS-1][Request_COURCE-1]=true;
}
else
{
cout<<"未通过安全性测试，不与以分配"<exit（0）;
}
for（i=0;iif（Array[i].num==Request_PROCESS-1）
continue;
if（Array[i].num!
=Request_PROCESS-1&&Finish[Array[i].num][Request_COURCE-1]==false&&Need[Array[i].num][Request_COURCE-1]<=Work[Request_COURCE-1]）{
Work[Request_COURCE-1]=Work[Request_COURCE-1]+Allocation[Array[i].num][Request_COURCE-1];
Finish[Array[i].num][Request_COURCE-1]=true;
}
}
for（i=0;i{
if（Finish[i][Request_COURCE-1]==true）
continue;
else
{
cout<<"未通过安全性测试，不与以分配"< exit（0）;
}
}
cout<<'\n'<<"找到一个安全序列:
"<<"P"<";
for（i=0;iif（Array[i].num==Request_PROCESS）
continue;
else
cout<<"P"<";
}
cout<<'\n'<<"已通过安全性测试!
"<Allocate_Source（）;
}
voidRUN（void）{ //执行银行家算法
cout<<"*************************************************"<<'\n'<<"点击1执行!
"
<<'\n'<<"点击2退出!
"
<<'\n'<<"*************************************************"<cin>>flag;
if（flag==2）
exit（0）;
if（flag==1）
{
cout<<"开始扫描请求信息!
"<DWORDm_delay=3000;
Sleep（m_delay）;
if（Request_COURCE_NEMBER>Need[Request_PROCESS-1][Request_COURCE-1]）
{
cout<<'\n'<<"第"< cout<<"可是已超出该进程尚需的该类资源的最大数量,所以不予以分配!
!
"<exit（0）;
}
if（Request_COURCE_NEMBER>Available[Request_COURCE-1]）
{
cout<<'\n'<<"第"< cout<<"可是系统中尚无足够的资源,所以进入等待队列!
!
"<exit（0）;
}
else{
Available[Request_COURCE-1]=Available[Request_COURCE-1]-Request_COURCE_NEMBER;
Allocation[Request_PROCESS-1][Request_COURCE-1]=Allocation[Request_PROCESS-1][Request_COURCE-1]+Request_COURCE_NEMBER;
Need[Request_PROCESS-1][Request_COURCE-1]=Need[Request_PROCESS-1][Request_COURCE-1]-Request_COURCE_NEMBER;
cout<<"扫描通过"<Sleep（m_delay）;
Test_Safty（）;
}
}
else{
cout<<"输入错误,请重新输入!
"<<'\n';
RUN（）;
}
}
voidmain（void）{
Read_Initiate（）;
cout<for（inti=0;icout<cout<for（i=0;ifor（intj=0;jcout<cout<}
DWORDm_delay=3000;
Sleep（m_delay）;
cout<<"读入成功"<<'\n';
Allocated_list（）;
for（i=0;ifor（intj=0;jcout<cout<}
Sleep（m_delay）;
cout<<"读入成功"<<'\n';
Set_Need（）;
for（i=0;ifor（intj=0;jcout<cout<}
Sleep（m_delay）;
cout<<"设置成功"<<'\n';
Read_Request（）;
cout<<'\n'<<"第"<cout<<'\n'<<"读入成功"<<'\n';
RUN（）;
}
注:
数组Array[I]表示第I+1个实际意义量需要创建三个txt文本。
1.Initiate.txt文本
3332 //共有3类资源,Available[0]=3;Available[1]=3;Available[2]=2
5 //当前系统中有个进程
753 //Max[0][0]=7
322 //Max[1][1]=3
902
222
433
2.Allocated_list.txt文本
010 //Allocation[0][1]=1
200
302
211
002
3.Request_list.txt文本
211 //第2个进程请求第1类资源1个Request[1][0]=1
本程序假设当前时刻只有一个进程请求某一类资源n个.
若要满足某个进程当前时刻同时请求不止一类资源,则需要为最大需求矩阵Max,分配矩阵Allocation和需求矩阵Need增加维数,当然代码量也将大大增加,但是算法逻辑本身并无变化.
升级会员 