银行家算法的模拟实现Word格式文档下载.docx
《银行家算法的模拟实现Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《银行家算法的模拟实现Word格式文档下载.docx（25页珍藏版）》请在冰豆网上搜索。
资源申请者不能强行的从资源占有者手中夺取资源，资源只能由占有者自愿释放
3）请求和保持（部分分配，占有申请）
一个进程在申请新的资源的同时保持对原有资源的占有（只有这样才是动态申请，动态分配）
4）循环等待
存在一个进程等待队列
{P1,P2,…,Pn},
其中P1等待P2占有的资源，P2等待P3占有的资源，…，Pn等待P1占有的资源，形成一个进程等待环路
5、死锁的解决方案
5.1产生死锁的例子
申请不同类型资源产生死锁
P1：
…
申请打印机
申请扫描仪
使用
释放打印机
释放扫描仪
P2：
申请同类资源产生死锁（如内存）
设有资源R，R有m个分配单位，由n个进程P1,P2,…,Pn（n>
m）共享。
假设每个进程对R的申请和释放符合下列原则：
*一次只能申请一个单位
*满足总申请后才能使用
*使用完后一次性释放
m=2，n=3
资源分配不当导致死锁产生
5.2死锁预防:
定义:
在系统设计时确定资源分配算法，保证不发生死锁。
具体的做法是破坏产生死锁的四个必要条件之一
①破坏“不可剥夺”条件
在允许进程动态申请资源前提下规定，一个进程在申请新的资源不能立即得到满足而变为等待状态之前，必须释放已占有的全部资源，若需要再重新申请
②破坏“请求和保持”条件
要求每个进程在运行前必须一次性申请它所要求的所有资源，且仅当该进程所要资源均可满足时才给予一次性分配
③破坏“循环等待”条件
采用资源有序分配法：
把系统中所有资源编号，进程在申请资源时必须严格按资源编号的递增次序进行，否则操作系统不予分配
6．安全状态与不安全状态
安全状态：
如果存在一个由系统中所有进程构成的安全序列P1，…Pn，则系统处于安全状态。
一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi（1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj（j<
i）当前占有资源量之和，系统处于安全状态（安全状态一定是没有死锁发生的）
不安全状态:
不存在一个安全序列，不安全状态一定导致死锁。
B、银行家算法
一、银行家算法中的数据结构
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
它是一个n×
m的矩阵，用以表示每一个进程尚需的各类资源数，如果Need[i,j]=K，则表示进程i还需要Rj类资源k个，方能完成其任务。
上述三个矩阵间存在下述关系：
Need[i,j]=Max[i,j]-Allocation[i,j]
二、银行家算法
设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等待。
三、安全性算法
系统所执行的安全性算法可描述如下：
（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
ABCAllocation
ABCNeed
ABCAvailable
ABC
P0753010743332
（230）
P1322200
（302）122
（020）
P2902302600
P3222211011
P4433002431
（1）T0时刻的安全性：
利用安全性算法对T0时刻的资源分配情况进行分析（如图2）可知，在T0时刻存在着一个安全序列｛P1，P3，P4，P2，P0｝，故系统是安全的。
Work
ABCNeed
ABCAllocation
ABCWork+allocation
ABCFinish
P1322122200532true
P3532011211743true
P4743431002745true
P27456003021047true
P010477430101057true
（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所示。
P123 0020302532true
P07457430107 55true
P27 5 56003021057true
由所进行的安全性检查得知，可以找到一个安全序列｛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所示。
Allocation
P0030723210
P1302020
P2302600
P3211011
P4002431
（5）进行安全性检查：
可用资源Available（2,1,0）已不能满足任何进程的需要，故系统进入不安全状态，此时系统不分配资源。
C、程序源代码。
#include<
stdio.h>
stdlib.h>
#ifndefMY_MAX
#defineMY_MAX5
#endif
intmax1[5][3]={
{7,5,3},
{3,2,2},
{9,0,2},
{2,2,2},
{4,3,3}
};
/*最大分配需求矩阵*/
intallocation1[5][3]={
{0,1,0},
{2,0,0},
{3,0,2},
{2,1,1},
{0,0,2}
/*已分配矩阵*/
intneed1[5][3]={
{7,4,3},
{1,2,2},
{6,0,0},
{0,1,1},
{4,3,1}
/*现在需求矩阵*/
intavailable1[3]={3,3,2};
/*现可利用矩阵*/
intmax[10][10],allocation[10][10],need[10][10],available[10];
intn_proc;
/*进程数*/
inttype_src;
/*资源种类数*/
int request[10][10];
/*进程请求资源*/
intwork[10];
/*可供进程继续运行所需资源的向量*/
int finish[10];
/*标识是否有足够的资源分配给进程*/
int index[10];
/*用于记录进程顺序*/
intt=0;
/*记录当前的进程数*/
intserial_proc=0;
/*当前请求进程*/
/*-------------------------------------------------------------------------------------------------------------*/
/*生成确定范围[min,max]内的随机数*/
intrandom_num（intmin,intmax）
{
inti,range;
doublej;
range=max-min;
i=rand（）;
j=（（double）i/（double）RAND_MAX）;
i=（int）（j*（double）range）;
i+=min;
returni;
}
/*手动输入时的初始化数据*/
voidinit0_data（void）
inti,j;
n_proc=5;
type_src=3;
for（i=0;
i<
n_proc;
i++）
for（j=0;
j<
type_src;
j++）
max[i][j]=max1[i][j];
allocation[i][j]=allocation1[i][j];
need[i][j]=need1[i][j];
for（j=0;
available[j]=available1[j];
index[i]=-1;
/*自动时的初始化数据*/
voidinit1_data（void）
inti,j,k1=0;
n_proc=random_num（1,MY_MAX）;
type_src=random_num（1,MY_MAX）;
do{
max[i][j]=random_num（0,MY_MAX）;
k1=0;
k1+=max[i][j];
}while（k1==0）;
allocation[i][j]=random_num（0,max[i][j]+1）;
if（allocation[i][j]==max[i][j]）
k1++;
}while（k1==type_src）;
need[i][j]=max[i][j]-allocation[i][j];
do{
available[j]=random_num（0,MY_MAX）;
for（i=0;
{
for（j=0;
if（need[i][j]>
available[j]）
{
k1++;
break;
}
}
}while（k1==n_proc）;
/*自动请求数据*/
voidproc_require1（void）
intj,tmp;
serial_proc=index[0];
printf（"
[%d]请求资源数：
"
serial_proc）;
printf（"
%2d"
request[serial_proc][j]=random_num（0,MY_MAX））;
tmp=0;
tmp+=request[serial_proc][j];
}while（tmp==0）;
voidproc_require0（void）
require0:
printf（"
\t现在第?
进程请求\n"
）;
scanf（"
%d"
&
serial_proc）;
if（serial_proc<
0||serial_proc>
=n_proc）
{
printf（"
进程号非法（越界）\n"
gotorequire0;
}
tmp=0;
tmp+=need[serial_proc][j];
if（!
tmp）
[%d]该进程处于完成状态\n"
gotorequire0;
\t对[%d]进程,各资源要求\n"
scanf（"
request[serial_proc][j]）;
\n"
/*请求资源超过需求资源*/
intover_need（）
intj;
if（request[serial_proc][j]>
need[serial_proc][j]）
\t请求资源超过需求资源\n"
return1;
return0;
/*请求资源超过可利用资源*/
intover_avail（）
\t[%d]请求资源超过可利用资源\n"
/*资源申请成功*/
intapply_success（intbe_need,intbe_avail）
if（be_need==0&
&
be_avail==0）
{
return1;
}
return0;
/*安全性检查*/
intcheck_security（）
inti,j,tmp;
work[j]=available[j];
finish[i]=0;
t=0;
L2:
if（finish[i]==0）/*没有进行安全检查*/
tmp=1;
work[j]）
tmp=0;
if（!
continue;
else
work[j]+=allocation[i][j];
finish[i]=1;
tmp=0;
tmp+=need[i][j];
if（tmp）
index[t++]=i;
gotoL2;
if（finish[j]==0）
return0;
/*银行家算法主体*/
voidbanker（）
intallocation_t[10],available_t[10],need_t[10];
/*临时变量*/
inttmp;
升级会员 