操作系统第七章实验死锁的避免Word文档下载推荐.docx
《操作系统第七章实验死锁的避免Word文档下载推荐.docx》由会员分享,可在线阅读,更多相关《操作系统第七章实验死锁的避免Word文档下载推荐.docx(15页珍藏版)》请在冰豆网上搜索。
=Vi+∑Aji(j=1...<
k-1>
),k=1,2,…,n;
i=1,2,…,m}
此公式为安全序列(参考教材201页)
3.程序流程图
1、系统主要过程流程图
2、银行家算法流程图
3、安全性算法流程图
4.源程序
本程序在c++编译器cfree上通过测试,vc6.0没有经过测试。
说明:
这里建立了如教材204-206页上面的一个例子,模拟了5个进程请求资源的情况。
具体可以对照教材说明进行查阅。
#include<
iostream>
usingnamespacestd;
voidprint(int*Max,int*Allocation,int*Need,int*Available,intp,intr)
{
inti,j,flag=1;
cout<
<
("
进程号请求的占用的C-A:
需要的可用"
)<
endl;
"
P[i]ClaimAllocationNeedAvailable"
endl<
//这是一个表头,下面是英文,上面用汉字说明作用
for(i=0;
i<
p;
i++)
{
cout<
P"
'
\t'
;
for(j=0;
j<
r;
j++)
{
cout<
*(Max+i*r+j)<
"
}
//制表符,用于排列,无特殊意义
*(Allocation+i*r+j)<
*(Need+i*r+j)<
if(flag==1)
for(j=0;
{
cout<
*(Available+j)<
}
flag=0;
}
}
boolcheckSafe(int*Need,int*Allocation,int*Available,intp,intr)
inti=0,j=0,k=0,m=0,count=0,flag1=0,flag2=0;
int*list,*Work;
//设置工作向量Work,安全序列list,均用指针来做。
数组太麻烦了
bool*Finish;
//完成标志Finish
Work=newint[r];
Finish=newbool[p];
list=newint[p];
//初始化完成标志Finish,默认为false
*(Finish+i)=false;
//初始化工作向量Work
*(Work+i)=*(Available+i);
//进行安全检查
while(k<
p)
//判断Finish[i]是否为true,且需求向量小于工作向量
flag1=0;
if(*(Finish+m)!
=true)
if(*(Need+m*r+j)>
*(Work+j))
{
flag1=0;
break;
}
flag1=1;
//若flag1==1即Finish[i]为true,且需求向量小于工作向量,则该进程可以获得资源
if(flag1==1)
*(Work+j)+=*(Allocation+m*r+j);
*(Finish+m)=true;
*(list+k)=m;
count=0;
k++;
else
count++;
if(count==5)
break;
m++;
if(m==5)
m=0;
//若所有进程的*(Finish+i)==true,表示系统处于安全状态
if(*(Finish+i)!
flag2=0;
flag2=1;
delete[]Work;
delete[]Finish;
//若系统处于安全状态,则输出存在的安全序列,否则安全检测算法结束
if(flag2==1)
{
存在安全序列:
for(i=0;
*(list+i)<
delete[]list;
returntrue;
else
returnfalse;
intmain()
intp=5,r=3;
//进程数为5,资源数为3
//Max为5*3的最大需求矩阵,Available为可利用资源向量,
//Allocation为5*3的分配矩阵,Need为5*3的需求矩阵,请求向量Request1
int*Max,*Available,*Allocation,*Need,*Request1;
Max=newint[p*r];
Available=newint[r];
Allocation=newint[p*r];
Need=newint[p*r];
Request1=newint[r];
//初始化Max矩阵
//753
//322
//902
//222
//433
*(Max+0*r+0)=7;
*(Max+0*r+1)=5;
*(Max+0*r+2)=3;
*(Max+1*r+0)=3;
*(Max+1*r+1)=2;
*(Max+1*r+2)=2;
*(Max+2*r+0)=9;
*(Max+2*r+1)=0;
*(Max+2*r+2)=2;
*(Max+3*r+0)=2;
*(Max+3*r+1)=2;
*(Max+3*r+2)=2;
*(Max+4*r+0)=4;
*(Max+4*r+1)=3;
*(Max+4*r+2)=3;
//初始化Allocation矩阵
//010
//200
//302
//211
//002
*(Allocation+0*r+0)=0;
*(Allocation+0*r+1)=1;
*(Allocation+0*r+2)=0;
*(Allocation+1*r+0)=2;
*(Allocation+1*r+1)=0;
*(Allocation+1*r+2)=0;
*(Allocation+2*r+0)=3;
*(Allocation+2*r+1)=0;
*(Allocation+2*r+2)=2;
*(Allocation+3*r+0)=2;
*(Allocation+3*r+1)=1;
*(Allocation+3*r+2)=1;
*(Allocation+4*r+0)=0;
*(Allocation+4*r+1)=0;
*(Allocation+4*r+2)=2;
//初始化可利用资源向量Available
//332
*(Available+0)=3;
*(Available+1)=3;
*(Available+2)=2;
//初始化Need矩阵,c-a
for(inti=0;
p*r;
*(Need+i)=*(Max+i)-*(Allocation+i);
//打印初始化数据
T0时刻的系统资源分配情况:
print(Max,Allocation,Need,Available,p,r);
//p1请求资源矩阵为Request1(1,0,2)
*(Request1+0)=1;
*(Request1+1)=0;
*(Request1+2)=2;
P1进程的请求向量为:
for(intj=0;
*(Request1+j)<
//请求资源数与最大需求资源数进行逐一比较
intflag=0;
if(*(Request1+i)>
*(Need+1*r+i))
flag=1;
//若请求资源数小于最大需求资源数,则进行资源分配判断,否则算法结束
if(flag==1)
//请求资源数与剩余资源数进行逐一比较
intflag2=0;
for(inti=0;
if(*(Request1+i)>
*(Available+i))
flag=0;
break;
else
flag2=1;
//若请求资源数小于最大需求资源数,则进行试探分配,否则算法结束
if(flag2==1)
{
//系统试探着进行资源分配
for(inti=0;
*(Available+i)-=*(Request1+i);
*(Allocation+1*r+i)+=*(Request1+i);
*(Need+1*r+i)-=*(Request1+i);
//试探分配完成后,对该状态进行安全检测,若通过检测,则分配,
//否则本次试探分配作废,恢复原来资源分配状态
if(checkSafe(Need,Allocation,Available,p,r))
分配资源后系统处于安全状态,可进行分配!
//打印分配后的数据
为进程分配资源后,T1时刻系统资源分配情况:
print(Max,Allocation,Need,Available,p,r);
cout<
程序测试BY:
金凯"
测试结果:
符合银行家算法,可以防止死锁"
分配资源后系统处于不安全状态,系统不分配该资源!
//本次试探分配作废,恢复原来资源分配状态
for(inti=0;
*(Available+i)+=*(Request1+i);
*(Allocation+1*r+i)-=*(Request1+i);
*(Need+1*r+i)+=*(Request1+i);
请求资源出错,无足够资源可分配!
请求资源出错,请求资源数不能大于需求资源数!
delete[]Max;
delete[]Available;
delete[]Allocation;
delete[]Need;
delete[]Request1;
return0;
注解:
该程序用的数据是教材上面给出的,为证明特殊性我在下面的运行中先输出一次原始数据,然后修改p1的请求资源数,进行了一次无法分配的输出。
修改这一段程序:
//p1请求资源矩阵为Request1(1,0,2)
修改为:
*(Request1+0)=2;
运行程序后报错:
告诉说无法分配!
即验证了该程序的有效性。
5.心得体会:
通过本次实验,我对于银行家算法有了更详尽的认识。
死锁避免方法能支持更多的进程并发执行,让在可行的情况下让进程充分利用资源,而是动态的确定是否分配资源给提出请求的进程。
在这个算法中如果一个资源的分配会导致下一步死锁,系统便拒绝本次分配。
在编程的过程中发现会用到大量的指针,用指针来操作大量的数据比较方便,但最后应该记得释放资源。
从这次实验中我发现我对于c++掌握也有所不足,程序经过了多次修改才得以完善,在以后应该注重编程方面的训练。