死锁的检测与解除Word下载.docx
《死锁的检测与解除Word下载.docx》由会员分享，可在线阅读，更多相关《死锁的检测与解除Word下载.docx（22页珍藏版）》请在冰豆网上搜索。
。
该程序是在银行家算法的基础上添加了死锁的解除模块得来的，死锁的解除采用的方法是：
找到已分配资源最大的死锁进程，剥夺其已分配资源，再次检测是否发生死锁。
1）设
是进程
的请求向量，如果
，表示进程
需要
个
类型起源。
当
发出资源请求后，进行检查，如果合格，修改
、
的值。
2）用安全性算法检查是否存在安全序列，如果存在，输出安全序列；
如果不存在，即为死锁，进行解锁操作。
3）统计
的值，找出占用资源最多的进程
，将其撤销，回收占用的资源，修改一下的数据结构中的值：
；
用安全性算法进行检查，如果仍有死锁，重复步骤3，知道解锁为止。
4）输出安全序列。
程序主要包括四大模块，一是输入数据模块，二是资源请求模块，三是检测死锁模块，四是对死锁进行解除模块。
程序流程图如下：
四、程序清单及简单注释
//死锁的检测与解除.
#include<
iostream>
stdio.h>
iomanip>
#defineTRUE1
#defineFALSE0
usingnamespacestd;
intnumber=0;
//定义全局变量,number为请求资源的进程号
intnum=0;
//num为安全序列中进程的个数
intInput（）;
intoutput（）;
//******输出未解锁之前的资源分配情况*******
intoutput（int**max,int**need,int*work,int**allocation,intm,intn）
{inti,j,mark=1;
cout<
<
"
该时刻的资源分配情况如下：
endl;
各个矩阵：
|max|allocation|need|available|"
Process|Rescource|"
;
for（i=0;
i<
4;
i++）
{
for（j=0;
j<
n;
j++）
cout<
["
]"
"
}
|"
-----------------------------------------------------------"
m;
P["
]"
{
cout<
max[i][j]<
}
allocation[i][j]<
need[i][j]<
if（mark==1）
for（j=0;
work[j]<
mark=0;
getchar（）;
return0;
}
//********输出解锁之后的资源分配情况***********
intoutput2（int**need,int**allocation,int*work,int*ss,int*finish,int*p,intm,intn）
{inti,j,mark=1,tag;
|need|allocation|work|wor+allocation|finish|"
num;
tag=ss[i];
P["
tag<
need[tag][j]<
allocation[tag][j]<
work[j]+allocation[tag][j]<
work[j]=work[j]+allocation[tag][j];
if（finish[tag]=1）
TRUE"
else
FALSE"
//*************输入所有相关的信息*************
intInput（int**max,int**need,int*work,int**allocation,int*available,int*request,intm,intn,intflag）
{
intj;
请输入请求资源的进程号：
cin>
>
number;
if（number>
=n）
returnFALSE;
else
进程P["
number<
]对["
]类资源的请求数为：
//输入请求向量request
cin>
request[j];
for（j=0;
if（request[j]>
need[number][j]||request[j]>
available[j]）//判断请求向量的合法性
flag=FALSE;
returnflag;
//***********可用资源与需求矩阵的比较************
intcheck（int**need,int*work,intN,inti）
intj,c=0;
N;
if（need[i][j]>
work[j]）
c++;
if（c>
0）returnFALSE;
elseif（c==0）returnTRUE;
//*******************系统安全性的检测******************
intjudge（int**need,int*work,int**allocation,int*finish,int*p,int*ss,intm,intn）
{inti,j,k=0,count=0,flag=TRUE,mark=0,tag=0;
while（flag==TRUE）
{flag=FALSE;
for（i=0;
if（finish[i]==FALSE&
&
check（need,work,n,i）==TRUE）
for（j=0;
work[j]=work[j]+allocation[i][j];
//进程请求成功，完成作业后回收allocation的资源
finish[i]=TRUE;
p[i]=TRUE;
flag=TRUE;
ss[tag++]=i;
//存储进程，用于输出安全序列
break;
}//while（flag==TRUE）
if（flag==FALSE）
if（finish[i]==FALSE）
{
k++;
}
if（k>
0）
检测结果：
存在死锁进程!
if（k==0）
{cout<
不存在死锁进程!
输出安全序列为：
tag;
ss[i]<
returnTRUE;
//********************解锁***********************
voidunlock（int**need,int*available,int*work,int**allocation,int*finish,int*p,int*ss,intm,intn）
//统计死锁进程的资源数，找出最大的死锁进程，进行撤销
int*sum=newint[m],i,j,k=0,count2=0,flag;
int*temp=newint[n];
//用于暂存work数组里的值，间接调用request函数
temp[i]=work[i];
if（finish[i]==FALSE）
sum[i]=sum[i]+allocation[i][j];
//寻找占用资源最多的进程
count2=sum[0];
if（sum[i]>
count2）
count2=sum[i];
k=i;
//k标记的数组位置即为已分配资源最多的进程
撤销占用资源最大的进程P["
k<
work[i]=work[i]+allocation[k][i];
finish[k]=TRUE;
//完成对该进程的操作
p[k]=FALSE;
//不再对该进程进行判断
num--;
flag=judge（need,work,allocation,finish,p,ss,m,n）;
//再次进行判断是否存在安全序列
if（flag==TRUE）
成功解除死锁!
output2（need,allocation,work,ss,finish,p,m,n）;
allocation[number][i]=allocation[number][i]-available[i]+temp[i];
need[number][i]=need[number][i]+available[i]-temp[i];
}//恢复请求进程原始的资源分配
finish[k]=FALSE;
//初始化对该进程的操作
p[k]=TRUE;
//初始化对该进程进行判断
num++;
//恢复撤销进程之前的情况
work[j]=available[j];
//初始化work数组
cout<
getchar（）;
unlock（need,available,work,allocation,finish,p,ss,m,n）;
//*******************主函数***************
voidmain（）
inti,j,m,n,count=0,s=0;
intflag=FALSE;
charname;
endl<
\t\t\t\t死锁的检测与解除"
请输入进程数m：
num=m;
请输入资源数n：
int**max=newint*[m];
int**need=newint*[m];
int**allocation=newint*[m];
int*request=newint[n];
int*available=newint[n];
int*finish=newint[m];
int*p=newint[m];
int*work=newint[n];
int*ss=newint[m];
max[i]=newint[n];
need[i]=newint[n];
allocation[i]=newint[n];
请输入各个进程对各种资源的最大需求max：
j++）
{
进程P["
]对["
]类资源的最大需求为：
//输入max矩阵
cin>
max[i][j];
请输入已分配的矩阵allocation：
]已分配到的["
]类资源为：
//输入allocation矩阵
allocation[i][j];
if（allocation[i][j]>
max[i][j]）
输入数据大于最多需求数，重新输入！
j--;
elseneed[i][j]=max[i][j]-allocation[i][j];
请输入可分配的资源available：
{
]类可分配的资源为：
//输入available向量
available[i];
work[i]=available[i];
finish[i]=FALSE;
//输入finsish向量
p[i]=FALSE;
output（max,need,work,allocation,m,n）;
//输出目前的资源分配情况
i=0;
while（flag==FALSE&
n）//进程多次请求资源
{flag=TRUE;
work[j]=available[j];
ss[j]=0;
}//初始化缓存数组ss
finish[j]=FALSE;
p[j]=FALSE;
}//初始化各进程分配情况
flag=Input（max,need,work,allocation,available,request,m,n,flag）;
available[j]=available[j]-request[j];
work[j]=available[j];
need[number][j]=need[number][j]-request[j];
allocation[number][j]=allocation[number][j]+request[j];
}//修改请求资源后的资源分配情况
输出此时的资源分配情况：
flag=judge（need,work,allocation,finish,p,ss,m,n）;
if（flag==TRUE）
output2（need,allocation,work,ss,finish,p,m,n）;
输出死锁的进程：
for（i=0;
if（finish[i]==FALSE）
cout<
是否要进行解锁！
解锁请输入'
Y'
，不解锁请输入'
N'
cin>
name;
if（name=='
）
unlock（need,available,work,allocation,finish,p,ss,m,n）;
else
程序运行结束！
break;
}//else
flag=FALSE;
if（number<
n）
请求的资源数超过所拥有的资源数，进程P["
]等待！
不存在进程P["
]！
i++;
}//while（flag==FALSE&
五、实验结果
开始输入：
输入最大需求矩阵max：
输入已分配矩阵allocation：
输入可用资源向量available：
此时资源分配情况如下：
进程P[1]请求资源：
（请求成功）
（请求资源数超过可用资源）
进程P[2]请求资源：
（发生死锁）
检测到死锁产生，进行解锁：
如果一次解锁不成功，则继续剥夺下一个已分配资源最多的死锁进程的资源，直到死锁解除。
经检查，实验结果符合要求。
六、实验小结
通过这次实验，我对死锁的各方面理解都有了更深层次的认识。
一开始，对于死锁的解除，我只是从第一个进程开始剥夺其资源，也不管它是不是发生了死锁，一直剥夺到死锁解除为止。
然后，我又对程序进行改进，让其可以判断死锁进程与非死锁进程，然后从第一个死锁进程开始剥夺已分配资源。
到最后，我又对程序进一步完善，让其判断一下在死锁进程中，哪个的已分配资源最多，就先剥夺它的资源，直到死锁解除。
通过以上这几次对程序的改进，我不仅对死锁的解除有了更进一步的理解，也加深了对编程理念的认识。
一种好的编程习惯、编程理念不仅可以帮助减少工作量，更可以帮助编程人员对程序的思想进行全面理解，对程序需求进行全面理解。
升级会员 