死锁检测

实验四死锁检测实验

（一）实验目的

采用银行家算法来预防死锁是可靠的，但也是非常保守的，因为它限制了进程对资源的存取，从而降低了进程的并发运行程度。死锁检测并不限制进程对资源的申请，只要有，就分配，但这也可能造成死锁。但由于死锁并不是经常发生的，故大大提高了系统运行的效率。通过本实验，可使学生进一步加深理解和掌握死锁的检测算法。

（二）实验题目

两个题目任选其一：

1、编写对每种类型多个资源的死锁检测算法。

2、使用检测“进程—资源循环等待链”的方法，编写死锁检测算法（有参考代码）（三）实验要求

题目1：

（1）死锁检测算法的数据结构参考教材3.4.2节图3-6的现有资源矩阵E、可用资源矩阵A、当前分配矩阵C、进程请求资源矩阵R。

（2）完成对教材中图3-7的死锁检测算法例子的测试。

（3）完成在图3-7基础上，修改进程2的请求分别为2 1 0 1 下的死锁检测。

题目2：

（1）利用“进程—资源循环等待链”的方法，编写死锁检测算法的具体方法可参考教材

3.4.1节的算法，在了解此算法思想的基础上，也可参考给定代码；具体代码描述见

附件1。

（2）利用教材图3-5 a）中的资源分配图完成对该算法的测试。

（四）实验报告要求

?画出所实现算法的详细框图；

?说明所采用的数据结构；

?列出输入数据（进程和所申请的资源数据可用命令行或文件输入）；

?列出运算的输出结果（输入结果包括是否死锁，死锁进程有哪些，也可包含中间结果）；

?实验总结与心得。

?根据情况可以列出代码。

附件1：

模拟死锁检测算法描述

1．输入：

“资源分配表”文件，每一行包含资源编号、进程编号两项（均用整数表示，并用空格分隔开），记录资源分配给了哪个进程。

“进程等待表”文件，每一行包含进程编号、资源编号两项（均用整数表示，并用空格分隔开），记录进程正在等待哪个资源。

下面是一个示例：

资源分配表：

1 1

2 2

3 3

进程等待表：

1 2

2 3

3 1

2．处理要求：

程序运行时，首先提示“请输入资源分配表文件的文件名：”；再提示“请输入进程等待表文件的文件名：”。

输入两个文件名后，程序将读入两个文件中的有关数据，并按照死锁检测算法进行检测。3．输出要求：

第一行输出检测结果：有死锁或无死锁。

第二行输出进程循环等待队列，即进程编号（如果有死锁）。

4．死锁检测算法：检测算法通过反复查找进程等待表和资源分配表，来确定进程Pj对资源ri的请求是否导致形成环路，若是，便确定出现死锁。

5．源代码参考：

#include

#include

#include

const int MAXQUEUE=100; //定义表的最大行数

typedef struct node{

int resource;

int process;

}cell; //边的结构（一个资源节点、一个进程节点）

cell occupy[MAXQUEUE]; //分配边数组

int occupy_quantity; //分配边的数量

cell wait[MAXQUEUE]; //申请边数组

int wait_quantity; //申请边的数量

//初始化函数

void initial()

{

int i;

for(i=0;i

occupy[i].process=-1;

occupy[i].resource=-1;

wait[i].process=-1;

wait[i].resource=-1;

}

occupy_quantity=0;

wait_quantity=0;

}

//读数据文件

int readData()

{

FILE *fp;

char fname[20];

int i;

cout<<"请输入资源分配表文件的文件名:"<

//strcpy(fname,"d:\tmp\trouble1.txt ");

cin>>fname;

if((fp=fopen(fname,"r"))==NULL){

cout<<"错误,文件打不开,请检查文件名:)"<

return 0;

}

else{

while(!feof(fp)){

fscanf(fp,"%d %d",&occupy[occupy_quantity].resource,&occupy[occupy_quantity].process);

occupy_quantity++;

}

}

cout<<"请输入进程等待表文件的文件名:"<

//strcpy(fname,"d:\tmp\trouble2.txt");

cin>>fname;

if((fp=fopen(fname,"r"))==NULL){

cout<<"错误,文件打不开,请检查文件名:)"<

return 0;

}

else{

while(!feof(fp)){

fscanf(fp,"%d %d",&wait[wait_quantity].process,&wait[wait_quantity].resource);

wait_quantity++;

}

}

//输出所读入的数据

cout<

cout<<"━━━━━━━━━━━━━━━━━━━━━━━"<

cout<<"资源分配表"<

cout<<"资源编号进程编号"<

for(i=0;i

cout<<" "<

}

cout<<"───────────────────────"<

cout<<"进程等待表"<

cout<<"进程编号资源编号"<

for(i=0;i

cout<<" "<

}

return 1;

}

//检测

void check()

{

int table[MAXQUEUE][MAXQUEUE];

int table1[MAXQUEUE][MAXQUEUE];

int i,j,k;

int flag,t,p;

int max_process;

//初始化表格

for(i=1;i

for(j=1;j

table[i][j]=0;

table1[i][j]=0;

}

}

//先找到进程最大编号

max_process=-1;

for(i=0;i

if(occupy[i].process>max_process){

max_process=occupy[i].process;

}

}

for(i=0;i

if(wait[i].process>max_process){

max_process=wait[i].process;

}

}

for(i=0;i

for(j=0;j

if(wait[i].resource==occupy[j].resource){

table[wait[i].process][occupy[j].process]=1;

table1[wait[i].process][occupy[j].process]=1;

}

}

}

cout<<"初始等待占用表:"<

for(i=1;i

cout<

}

cout<

}

cout<

for(i=1;i

for(j=1;j

for(k=1;k

table[i][j]=table[i][j]||(table[i][k]&&table[k][j]); //&&与，||或

}

}

}

cout<<"检测后的等待占用表:"<

for(i=1;i

for(j=1;j

cout<

}

cout<

}

flag=-1;

for(i=1;i

if(table[i][i]==1){

flag=i;

break;

}

}

cout<

cout<<"───────────────────"<

if(flag!=-1){

cout<<"存在死锁"<

cout<<"进程循环等待队列:";

p=flag; //存在进程循环等待队列的那一进程

//进程循环等待队列中的所有进程是table表中的这一行是1的进程,只是顺序要再确定//即该进程无法运行，则其他它后面运行的进程也无法运行

t=1;

while(t){

cout<

for(j=1;j

if(table1[p][j]==1){

if(table[j][flag]==1){

p=j;

break;

}

}

}

if(p==flag)t=0; //出现节点的重复/即环，结束

}

cout<

}

else{

cout<<"不存在死锁"<

}

}

//显示版权信息函数

void version()

{

cout<

cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<

}

void main()

{

int flag;

version();

initial();

flag=readData();

if(flag)check();

}