课程设计-死锁的检测与分析系统的设计

**大学

计算机科学与技术学院课程设计报告（200 6 ~200 7 学年度第2学期）

课程名称操作系统课程设计项目名称死锁的检测与分析系统的设计姓名学号

专业班级

地点教师

（一）设计任务与目的：

目的与要求：

本设计的目的是通过对死锁检测算法的模拟，来了解死锁检测中的数据结构的设计和使用以及资源分配图在死锁检测中的应用。具体要求如下：

⑴模拟一个死锁检测算法；

⑵该算法能通过简化资源分配图来检测死锁；

⑶资源分配图可以用矩阵的形式表示；

⑷输出结果为有死锁或无死锁。

（二）设计思路及过程：

（1）定义结构体数组node resource[MAX]; node process[MAX]；

（2）输入资源号和进程号并存入一维数组resource[MAX];和process[MAX]；

（3）将刚才输入的资源号和进程号按表格输出（见运行结果）；

（4）根据进程间的关系process[a].ziyuan==resource[b].ziyuan

（5）将初始等待表中的list[process[a].jinchen][resource[b].jinchen]赋值为1;

（6）根据bij＝bij ∨(bik∧bkj)判断初始等待占用表中的进程是否含有间接等待关系实现语句为：list[a][b]=list[a][b]||(list[a][k]&&list[k][b])

（7）利用循环语句判断baa(a＝1，2，…，n)是否等于1，取值为"1"时，就表示存在一组进程，它们循环等待资源，在资源分配图中会形成环路，也即系统出现了死锁，否则无死锁！

（三）系统的原理框图(资源分配图按照我两次输入的数据来画)：

（1）第一次输入的资源表和进程表：

资源分配表：进程等待表：

资源号进程号进程号资源号

1 1 1 2

2 2 2 3

3 3 3 1

（2）第二次输入的资源表和进程表：

资源分配表：进程等待表：

资源号进程号进程号资源号

1 2 2 2

2 1 1 3

3 3

（四）实验中主要问题及故障现象的分析及设计结论：本实验主要出现的问题就是如何将资源分配图转化为矩阵的于那里比较难理解，编程方面利用FOR循环语句将其实现还是

比较容易实现的，此实验的输出结果比较简单，但中间过程有点复杂，利用FOR语句比较多，但搞清了等待占用表的原理在编程方面就比较好实现了

（五）编程体会和心得：

刚看到‘死锁的检测与分析’感觉还是蛮简单的，但看了设计的任务之后感觉无从着手，没有思路，不能理解，然后回寝室后,连忙查看相关的书,以及通过上网查找相关的资料,最终对如何将资源分配图转化成矩阵有了初步的认识和了解。此次课程设计共用了大概一个星期时间，经过跟同学请教和看书.上网查找资料，最终将程序编写完成（按照附的等待占用表编写），并且符合了实验要求！

通过这次实践,我很高兴可以学到书上没有的知识，让我对于死锁有了更深入的理解。我相信，只要自己在每一次实践中能仔细思考，课程设计其实都不会很难,关键在于自己能不能认真思考,能不能亲自动手做实验，而不是想着其他人的劳动果实,其次你还要多操作,只有多操作才能从中发现问题,才能及时向老师和同学请教,解决问题,从而更好的掌握书本中知识。还有通过这次实践也让我懂得了；老师安排课程设计目的不在于你做了多少,不在于你做得好不好,关键在于你能否认真去对待,在于你能否通过这次设计对课本上知识有了更深刻的认识,在于能否从中学到书本上学不到的知识。因此，我会认真地对待我的每一次实验。

（六）源程序：

#include

void GAO()

{

cout<

cout<<" ************************************************"<

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

typedef struct //定义结构体

{

int ziyuan;

int jinchen;

}node; //结构体变量

const int MAX=99; //定义表的最大行数

node resource[MAX]; //结构体变量数组

node process[MAX]; //结构体变量数组

int RNUM; // 定义资源数

int PNUM; // 定义进程数

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void first() //函数的初始化

{

int s;

for(s=0;s

{

resource[s].jinchen=0;

resource[s].ziyuan=0;

process[s].jinchen=0;

process[s].ziyuan=0;

}

RNUM=0;

PNUM=0;

}

//读数据文件

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int input() //输入资源表和进程表(以数字表示资源号和进程号) {

int i,x,y;

cout<<"请输入资源和进程的总数(中间以空格区分):"<

cin>>x; cin>>y;

RNUM=x;

PNUM=y;

cout<<"请输入资源分配表的资源号(中间以空格区分):"<

for(i=0;i

{ cin>>resource[i].ziyuan;}

cout<<"请输入资源分配表的进程号(中间以空格区分):"<

for(i=0;i

{ cin>>resource[i].jinchen;}

cout<<"请输入进程等待表的进程号(中间以空格区分):"<

for(i=0;i

{ cin>>process[i].ziyuan;}

cout<<"请输入进程等待表的资源号(中间以空格区分):"<

for(i=0;i

{ cin>>process[i].jinchen;}

cout<<"----------------------------------------------------"<

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

for(i=0;i

cout<<" "<

}

cout<<"----------------------------------------------------"<

cout<<"进程等待表:"<

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

for(i=0;i

cout<<" "<

}

return 1;

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void sisuo() //定义类检验是否死锁

{

int list[MAX][MAX]; //定义二维数组代表输入的资源和进程号int a, b, k, sign, maxpp=0;

for(a=0;a

{

for(b=0;b

{

list[a][b]=0; //初始化数组，将数组的每个元素初始化为0

}

}

for(a=0;a

if(resource[a].jinchen>maxpp)

{

maxpp=resource[a].jinchen;

}

}

for(a=0;a

{

if(process[a].jinchen>maxpp)

{

maxpp=process[a].jinchen;

}

}

for(a=0;a

{

for(b=0;b

{

if(process[a].ziyuan==resource[b].ziyuan)

{

list[process[a].jinchen][resource[b].jinchen]=1;

}

}

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

for(a=1;a

{

for(b=1;b

{

cout<

}

cout<

}

cout<

for(a=0;a

{

for(b=0;b

{

for(k=0;k

{

list[a][b]=list[a][b]||(list[a][k]&&list[k][b]); //根据bij＝bij ∨(bik∧bkj) 判断初始等待占用表中的进程是否含有间接等待关系

}

}

}

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

for(a=1;a

{

for(b=1;b

{

cout<

}

cout<

}

cout<

cout<<"----------------------------------------------"<

for(a=0;a

{

if(list[a][a]==1) //利用循环语句判断baa(a＝1，2，…，n)是否等于1，取值为"1"时，就表示存在一组进程，它们循环等待资源，在资源分配图中会形成环路，也即系统出现了死锁

{

sign=1; //标志

break;

}

}

if(sign==1)

{

cout<<"存在死锁"<

}

if (sign!=1)

{

cout<<"不存在死锁"<

}

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void main() //主函数

{

GAO();

first();

input();

sisuo();

}

（七）实验结果（如图）：

附：

（1）系统软件硬件环境：apple操作系统，AMD Athlon(tn) 64 Processor 3000+，1.81 GHz, 480MB的内存，在

microsoft visual c++ 6.0上运行成功。

（2）实验数据：

resource[s].jinchen=0; 资源分配表中的进程号

resource[s].ziyuan=0; 资源分配表中的资源号

process[s].jinchen=0; 进程等待表中的进程号

process[s].ziyuan=0; 进程等待表中的资源号

RNUM=0; 资源总数

PNUM=0 进程总数

（3）使用说明及参考资料：

因为书上没有写关于等待占用表这方面的知识，所以本人在网上搜集了一些资料，并根据以下等待占用的关系的思路来写程序，判断是否存在死锁也是根据下面用倒的公式，构造的矩阵即初始等待占用表，资料如下：

首先，"死锁检测"程序根据两张表中记录的进程占用资源和等待资源的情况用一个矩阵来表示，矩阵中的每一个元素指

出进程间是否存在"等待占用"关系。矩阵的结构如表9-5-1

所示。

然后，死锁检测程字运行如下程序：

for k：＝l to n do

for i：＝1 to n do

for j：＝1 to n do

bij：＝bij ∨(bik∧bkj)

其中运算符"∨"为"或"运算，"∧"为"与"运算。因而bik ∧bkj表示当bik取值为"1"且bkj取值也为"1"时运算结果也为"1"，否则结果为"0"。也就是说，如果(bik∧bkj)，取值为"1"，则表示进程Pi与进程Pj之间具有间接等待关系。通过

表达式bij：＝bij ∨(bik∧bkj)能够使Pi与Pj原来就有等待占用关系时保持bij为"1"，并且在Pi与Pj有间接等待占

用关系时也把bij置为"1"。

所以，死锁检测程序运行上述程序后能把进程等待资源的关系(包括间接等待关系)都在矩阵中表示出来。显然，当矩阵中有某个bii(i＝1，2，…，n)取值为"1"时，就表示存在一组进程，它们循环等待资源，在资源分配图中会形成环路，也即系统出现了死锁。

例如，按图9-5-1的两张表，死锁检测程序首先构造出如表9-5-2所示的矩阵。

现在矩阵中有b12，b23，b31个元素为"1"，当进入循环检测程序运行后，对k＝1时的各 i，j进行检测，由于b31＝1和b12＝1而使得b32被置或"1"，继续对k＝2时的各i和j进行检测，通过(b12∧b23)将使b13成为"1"，通过(b32∧b23)将使b33成为"1"，由于b33＝1故已可断定系统有死锁发生。继续对k＝3时的检测，读者可以发现在循环程序运行结束时便有b11＝1和b22＝1。所以，可以肯定系统中不仅存在死锁，而且进程P1，P2，P3都已卷入死锁中。