操作系统课程设计银行家算法的模拟实现Word格式文档下载.docx
《操作系统课程设计银行家算法的模拟实现Word格式文档下载.docx》由会员分享,可在线阅读,更多相关《操作系统课程设计银行家算法的模拟实现Word格式文档下载.docx(19页珍藏版)》请在冰点文库上搜索。
![操作系统课程设计银行家算法的模拟实现Word格式文档下载.docx](https://file1.bingdoc.com/fileroot1/2023-4/29/0118a160-7e26-4198-a38f-0af18ebf5713/0118a160-7e26-4198-a38f-0af18ebf57131.gif)
永久性资源:
可以被多个进程多次使用(可再用资源)可抢占资源
不可抢占资源
临时性资源:
只可使用一次的资源;
如信号量,中断信号,同步信号等(可消耗性资源)
“申请--分配--使用--释放”模式
4、产生死锁的四个必要条件:
互斥使用(资源独占)、不可强占(不可剥夺)、请求和保持(部分分配,占有申请)、循环等待。
1)互斥使用(资源独占)
一个资源每次只能给一个进程使用。
2)不可强占(不可剥夺)
资源申请者不能强行的从资源占有者手中夺取资源,资源只能由占有者自愿释放。
3)请求和保持(部分分配,占有申请)
一个进程在申请新的资源的同时保持对原有资源的占有(只有这样才是动态申请,动态分配)。
4)循环等待
存在一个进程等待队列
{P1,P2,…,Pn},
其中P1等待P2占有的资源,P2等待P3占有的资源,…,Pn等待P1占有的资源,形成一个进程等待环路。
5、死锁预防:
定义:
在系统设计时确定资源分配算法,保证不发生死锁。
具体的做法是破坏产生死锁的四个必要条件之一。
①破坏“不可剥夺”条件
在允许进程动态申请资源前提下规定,一个进程在申请新的资源不能立即得到满足而变为等待状态之前,必须释放已占有的全部资源,若需要再重新申请
②破坏“请求和保持”条件。
要求每个进程在运行前必须一次性申请它所要求的所有资源,且仅当该进程所要资源均可满足时才给予一次性分配。
③破坏“循环等待”条件采用资源有序分配法:
把系统中所有资源编号,进程在申请资源时必须严格按资源编号的递增次序进行,否则操作系统不予分配。
6.安全状态与不安全状态安全状态:
如果存在一个由系统中所有进程构成的安全序列P1,…Pn,则系统处于安全状态。
一个进程序列{P1,…,Pn}是安全的,如果对于每一个进程Pi(1≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj(j<
i)当前占有资源量之和,系统处于安全状态(安全状态一定是没有死锁发生的)
不安全状态:
不存在一个安全序列,不安全状态一定导致死锁。
二.银行家算法
1、银行家算法中的数据结构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。
它是一个n×
m的矩阵,用以表示每一个进程尚需的各类资源数,如果Need[i,j]=K,则表示进程i还需要Rj类资源k个,方能完成其任务。
上述三个矩阵间存在下述关系:
Need[i,j]=Max[i,j]-Allocation[i,j]
2、银行家算法
设Requesti是进程Pi的请求向量。
如果Requesti[j]=k,表示进程只需要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)设置两个向量
①、工作向量Work。
它表示系统可提供给进程继续运行所需要的各类资源数目,它含有m个元素,执行安全算法开始时,Work=Available。
②、Finish。
它表示系统是否有足够的资源分配给进程,使之运行完成,开始时先做Finish[i]:
=false ;
当有足够资源分配给进程时,令 Finish[i]:
=true。
2)从进程集合中找到一个能满足下述条件的进程:
①、Finish[i]=false;
②、Need[i,j]<
=Work[j];
如找到,执行步骤(3);
否则,执行步骤(4)。
3)当进程Pi获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:
Work[j]:
=Work[i]+Allocation[i,j];
Finish[i]:
=true;
gotostep2;
4)如果所有进程的Finish[i]:
=true,则表示系统处于安全状态;
否则,系统处于不安全状态。
三.银行家算法之例
假定系统中有五个进程:
{P0,P1,P2,P3,P4}和三种类型的资源
{A,B,C},每一种资源的数量分别为10、5、7,在T0时刻的资源分配情况如
图1所示。
进程
资源情况
Max
Allocation
Need
Available
A
B
C
P0
7
5
3
1
4
2
(2
0)
P1
(3
2)
(0
P2
9
6
P3
P4
图1T0时刻的资源分配表
(1)T0时刻的安全性:
利用安全性算法对T0时刻的资源分配情况进行分析(如图2)可知,在T0时刻存在着一个安全序列{P1,P3,P4,P2,P0},故系统是安全的。
Work
Work+Allocation
Finish
true
10
图2T0时刻的安全序列
(2)P1请求资源:
P1发出请求向量Request1(1,0,2),系统按银行家算法进行检查:
①Request1(1,0,2)<
=Need1(1,2,2)
②Request1(1,0,2)<
=Available1(3,3,2)
③系统先假定可为P1分配资源,并修改Available,Allocation1和Need1
向量,由此形成资源变化情况如图1中的圆括号所示。
④再利用安全性算法检查此时系统是否安全。
如图3所示。
图3P1申请资源时的安全性检查
由所进行的安全性检查得知,可以找到一个安全序列{P1,P3,P4,P2,P0}。
因此系统是安全的,可以立即将P1所申请的资源分配给它。
(3)P4请求资源:
P4发出请求向量Request4(3,3,0),系统按银行家算法进行检查:
①Request4(3,3,0)≤Need4(4,3,1);
②Request4(3,3,0)不小于等于Available(2,3,0),让P4等待。
(4)P0请求资源:
P0发出请求向量Request0(0,2,0),系统按银行家算法进行检查。
①Request0(0,2,0)≤Need0(7,4,3);
②Request0(0,2,0)≤Available(2,3,0);
③系统暂时先假定可为P0分配资源,并修改有关数据,如图4所示。
图4为P0分配资源后的有关资源数据
(5)进行安全性检查:
可用资源Available(2,1,0)已不能满足任何进程的需要,故系统进入不安全状态,此时系统不分配资源。
3)详细设计及编码
1)银行家算法流程图
2)程序源代码#include<
iostream.h>
#include<
stdio.h>
stdlib.h>
string.h>
//定义全局变量
constintx=20,y=20;
//常量,便于修改
intAvailable[x];
//各资源可利用的数量
intAllocation[y][y];
//各进程当前已分配的资源数量intMax[y][y];
//各进程对各类资源的最大需求数
intNeed[y][y];
//尚需多少资源
intRequest[x];
//申请多少资源
intWork[x];
//工作向量,表示系统可提供给进程继续运行所需的各类资源数量
intFinish[y];
//表示系统是否有足够的资源分配给进程,1为是intp[y];
//存储安全序列
inti,j;
//i表示进程,j表示资源
intn,m;
//n为进程i的数量,m为资源j种类数
intl=0;
//l用来记录有几个进程是Finish[i]=1的,当l=n是说明系统状态是安全的
intcounter=0;
//函数声明
voidchushihua();
//初始化函数voidsafe();
//安全性算法
voidshow();
//函数show,输出当前状态voidbank();
//银行家算法
//voidjieshu();
//结束函数
voidchushihua()
{
cout<
<
"
输入进程的数量:
"
;
//从此开始输入有关数据
cin>
>
n;
输入资源种类数:
cin>
m;
endl<
输入各种资源当前可用的数量("
m<
种):
endl;
for(j=0;
j<
j++)
输入资源"
j<
可利用的数量Available["
]:
Available[j];
//输入数字的过程...
Work[j]=Available[j];
//初始化Work[j],它的初始值就是当前可用的资源数
}
输入各进程当前已分配的资源数量Allocation["
n<
]["
for(i=0;
i<
i++)
输入进程"
i<
当前已分配的资源"
数量:
Allocation[i][j];
Finish[i]=0;
//初始化Finish[i]
输入各进程对各类资源的最大需求Max["
]["
对资源"
的最大需求数:
Max[i][j];
if(Max[i][j]>
=Allocation[i][j]) //若最大需求大于已分配,则
计算需求量
Need[i][j]=Max[i][j]-Allocation[i][j];
else
Need[i][j]=0;
//Max小于已分配的时候,此类资源已足够不需再申
请
初始化完成"
//安全性算法函数voidsafe()
l=0;
i++)
{ //i++
if(Finish[i]==0)
{ //逐个查找Finish[i]==0的进程 条件一
counter=0;
//记数器for(j=0;
需求,记数
if(Work[j]>
=Need[i][j]) counter=counter+1;
//可用大于
条件二
安全序列
if(counter==m) //i进程的每类资源都符合Work[j]>
=Need[i][j]
p[l]=i;
//存储安全序列Finish[i]=1;
//i进程标志为可分配for(j=0;
j++)
Work[j]=Work[j]+Allocation[i][j];
//释放资源
l=l+1;
//记数,现在有L个进程是安全的,当L=N时说明满足i=-1;
//从第一个进程开始继续寻找满足条件一二的进程
//显示当前状态函数
voidshow()//函数show,输出当前资源分配情况
//局部变量
intAll[y];
//各种资源的总数量
当前的状态为:
各种资源的总数量:
for(j=0;
资源"
:
All[j]=Available[j];
//总数量=可用的+已分配的for(i=0;
i++) All[j]+=Allocation[i][j];
cout<
All[j]<
"
当前各种资源可用的量为(available):
Available[j]<
各进程已经得到的资源量(allocation):
j++)cout<
'
\t'
资源"
j;
for(i=0;
进程"
各进程还需要的资源量(need):
j++) cout<
资源"
Need[i][j];
//银行家算法函数voidbank()
进程申请分配资源:
intk=0;
//用于输入进程编号
boolr=false;
//初值为假,输入Y继续申请则置为真
do{//输入请求
输入申请资源的进程(0-"
n-1<
):
k;
while(k>
n-1)//输入错误处理
输入错误,重新输入:
输入申请资源的进程(0--"
输入该进程申请各类资源的数量:
do{ //do……while循环判断申请输入的情况
进程"
k<
申请资源["
]的数量:
Request[j];
if(Request[j]>
Need[k][j])
{ //申请大于需求量时出错,提示重新输入(贷款数目不允许超过需求数目)
申请大于需要量!
申请的资源"
的数量为"
Request[j]
大于进程"
对该资源需求量"
Need[k][j]<
。
重新输入!
于可利用量
?
}
else //先判断是否申请大于需求量,再判断是否申请大
Available[j])
{ //申请大于可利用量, 应该阻塞等待?
……
\n没有那么多资源,目前可利用资源
数量为"
本次申请不成功,进程等待!
Finish[k]=0;
//该进程等待
gotoppp;
//goto语句跳转,结束本次申请
}while(Request[j]>
Need[k][j]);
//Request[j]>
Available[j]||
//改变Avilable、Allocation、Need的值for(j=0;
Available[j]=Available[j]-Request[j];
Allocation[k][j]=Allocation[k][j]+Request[j];
Need[k][j]=Need[k][j]-Request[j];
Work[j]=Available[j];
//判断当前状态的安全性
safe();
//调用安全性算法函数if(l<
n)
l=0;
\n试分配后,状态不安全,所以不予分配!
恢复原状态
//恢复数据
Available[j]=Available[j]+Request[j];
Allocation[k][j]=Allocation[k][j]-Request[j];
Need[k][j]=Need[k][j]+Request[j];
//进程置为未分配状态
else
\n申请资源成功!
!
for(j=0;
if(Need[k][j]==0);
{ //有一种资源还没全部申请到,则该进程不可执行,
不能释放拥有的资源
l=1;
//置l为1,作为判断标志b