《计算机系统操作系统》银行家算法实验文档格式.docx

《计算机系统操作系统》银行家算法实验文档格式.docx

《《计算机系统操作系统》银行家算法实验文档格式.docx》由会员分享，可在线阅读，更多相关《《计算机系统操作系统》银行家算法实验文档格式.docx（15页珍藏版）》请在冰豆网上搜索。

互斥条件，请求和保持条件不剥夺条件，环路等待条件。

只要下面四个条件中有一个不具备，系统就不会出现死锁。

①互斥条件：

即某个资源在一段时间内只能由一个进程占有，不能同时被两个或两个以上的进程占有。

②不可抢占条件：

进程所获得的资源在未使用完毕之前，资源申请者不能强行地从资源占有者手中夺取资源，而只能由该资源的占有者进程自行释放。

③占有且申请条件：

进程至少已经占有一个资源，但又申请新的资源；

由于该资源已被另外进程占有，此时该进程阻塞；

但是，它在等待新资源之时，仍继续占用已占有的资源。

④循环等待条件：

存在一个进程等待序列{P1,P2,…,Pn},其中P1等待P2所占有的某一资源，P2等待P3所占有的某一资源，……，而Pn等待P1所占有的某一资源，形成一个进程循环等待环。

2、死锁对多道程序系统带来的影响？

3、如何预防死锁？

摒弃“请求和保持”条件，摒弃“不剥夺”条件，摒弃“环路等待”条件

4、死锁的预防：

什么是安全态？

如何保证多个进程在某个时刻是处于安全态的？

所谓安全态是指系统能按某种进程顺序（P1，P2,…，Pn）（称（P1，P2,…，Pn）序列为安全序列）来为每个进程Pi分配其所需资源，直至满足每个进程对资源的最大需求，使每个进程都顺利的完成。

四、设计方案

1、数据结构的建立

1）.可利用资源向量AVAILABLE。

这是一个含有M个元素的数组，其中的每一个元素代表一类可利用的资源数目，其3初始值是系统中所配置的该类全部可哦那个资源的数目，其数值随该类资源的分配和回收而动态的改变。

2）.最大需求矩阵MAX。

这是一个M*N的矩阵，它定义了系统中N个进程中的每一个进程对M类资源的最大需求。

3）.分配矩阵ALLOCATION。

这也是一个M*N的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。

4）.需求矩阵NEED。

这也是一个M*N的矩阵，用以表示每一个进程尚需的各类资源数。

5）.NEED[R,W]=MAX[R,W]-ALLOCATION[R,W]

数据结构详细介绍如下：

假设有M个进程N类资源，则有如下数据结构:

#defineW10

#defineR20

intA；

//总进程数

intB；

//资源种类

intALL_RESOURCE[W];

//各种资源的数目总和

intMAX[W];

//M个进程对N类资源最大资源需求量

intAVAILABLE;

//系统可用资源数

intALLOCATION[W];

//M个进程已经得到N类资源的资源量

intNEED[W];

//M个进程还需要N类资源的资源量

intRequest;

//请求资源个数

主要函数说明

voidshowdata（）;

//主要用来输出资源分配情况

voidchangdata（int）;

//主要用来输出资源分配后后的情况

voidrstordata（int）;

//用来恢复资源分配情况,如:

银行家算法时,由于分配不安全则要恢复资源分配情况

intchkerr（int）;

//银行家分配算法的安全检查

voidbank（）;

//银行家算

2、算法的设计

设Request[i]是进程Pi的请求向量。

如果Request[i,j]=k，表示Pi需k个Rj类资源。

当Pi发出资源请求后，系统按下述步骤进行检查:

（1）if（Request[i]<

=Need[i]）goto

（2）;

elseerror（“overrequest”）;

（2）if（Request[i]<

=Available[i]）goto（3）;

elsewait（）;

（3）系统试探性把要求资源分给Pi（类似回溯算法）。

并根据分配修改下面数据结构中的值。

Available[i]=Available[i]–Request[i]；

Allocation[i]=Allocation[i]+Request[i]；

Need[i]=Need[i]-Request[i];

（4）系统执行安全性检查，检查此次资源分配后，系统是否处于安全状态。

若安全，才正式将资源分配给进程以完成此次分配；

若不安全，试探方案作废，恢复原资源分配表，让进程Pi等待。

系统所执行的安全性检查算法可描述如下：

设置两个向量：

Free、Finish

工作向量Free是一个横向量，表示系统可提供给进程继续运行所需要的各类资源数目，它含有的元素个数等于资源数。

执行安全算法开始时，

Free=Available.

标记向量Finish是一个纵向量，表示进程在此次检查中中是否被满足，使之运行完成，开始时对当前未满足的进程做Finish[i]=false；

当有足够资源分配给进程（Need[i]<

=Free）时，Finish[i]=true，Pi完成，并释放资源。

（1）从进程集中找一个能满足下述条件的进程Pi

①Finish[i]==false（未定）

②Need[i]<

=Free（资源够分）

（2）当Pi获得资源后，认为它完成，回收资源:

Free=Free+Allocation[i];

Finish[i]=true;

Gotostep

（1）;

试探此番若可以达到Finish[0..n]:

=true，则表示系统处于安全状态，然后再具体为申请资源的进程分配资源。

否则系统处于不安全状态。

3、算法的优化

4、研究问题的推广

五、方案实施

1、任务划分

（1）流程图

①初始化算法流程图

②银行家算法流程图：

③安全性算法流程图：

2、具体代码

#include<

string.h>

iostream>

usingnamespacestd;

#defineFALSE0

#defineTRUE1

#defineW10//最大进程数W=10

#defineR20//最大资源总数R=20

intM;

intN;

intAVAILABLE[R];

//可利用资源向量

intMAX[W][R];

//最大需求矩阵

intALLOCATION[W][R];

//分配矩阵

intNEED[W][R];

//需求矩阵

intRequest[R];

//进程请求向量

voidinputdata（）;

//数据输入

//数据显示

voidchangdata（intk）;

//进程请求资源数据改变

voidrestoredata（intk）;

//数据恢复

intchksec（ints）;

//系统安全性的检测

intchkmax（ints）;

//检测最大需求

//检测分配的资源是否合理

voidmain（）

{inti,j;

inputdata（）;

for（i=0;

i<

M;

i++）

{j=chksec（i）;

if（j==0）break;

}

if（i>

=M）

cout<

<

"

错误提示：

经安全性检查发现，系统的初始状态不安全！

！

\n"

endl;

else

{cout<

提示：

经安全性检查发现，系统的初始状态安全！

bank（）;

}

}

voidinputdata（）

{inti=0,j=0,p;

cout<

请输入总进程数:

do{

cin>

>

if（M>

W）cout<

endl<

总进程数超过了程序允许的最大进程数，请重新输入:

}while（M>

W）;

请输入资源的种类数:

do{cin>

N;

if（N>

R）

资源的种类数超过了程序允许的最大资源种类数，请重新输入:

}while（N>

R）;

请依次输入各类资源的总数量，即设置向量all_resource:

i++）cin>

ALL_RESOURCE[i];

请依次输入各进程所需要的最大资源数量，即设置矩阵max:

for（i=0;

{

for（j=0;

j<

j++）

do{cin>

MAX[i][j];

if（MAX[i][j]>

ALL_RESOURCE[j]）

该最大资源数量超过了声明的该资源总数,请重新输入:

}while（MAX[i][j]>

ALL_RESOURCE[j]）;

请依次输入各进程已经占据的各类资源数量，即设置矩阵allocation:

do{cin>

ALLOCATION[i][j];

if（ALLOCATION[i][j]>

MAX[i][j]）

cout<

已占有的资源数量超过了声明的最大资源数量,请重新输入:

}while（ALLOCATION[i][j]>

MAX[i][j]）;

for（j=0;

NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];

{p=ALL_RESOURCE[j];

{p=p-ALLOCATION[i][j];

AVAILABLE[j]=p;

if（AVAILABLE[j]<

0）

AVAILABLE[j]=0;

voidshowdata（）

各种资源的总数量，即向量all_resource为:

"

;

资源"

:

ALL_RESOURCE[j];

当前系统中各类资源的可用数量，即向量available为:

AVAILABLE[j];

各进程还需要的资源数量，即矩阵need为:

i++）

进程P"

cout<

NEED[i][j]<

各进程已经得到的资源量，即矩阵allocation为:

ALLOCATION[i][j]<

}cout<

}

voidchangdata（intk）

{intj;

j++）

{

AVAILABLE[j]=AVAILABLE[j]-Request[j];

ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];

NEED[k][j]=NEED[k][j]-Request[j];

voidrestoredata（intk）

{

intj;

{AVAILABLE[j]=AVAILABLE[j]+Request[j];

ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];

NEED[k][j]=NEED[k][j]+Request[j];

intchksec（ints）

intWORK,FINISH[W];

inti,j,k=0;

FINISH[i]=FALSE;

{WORK=AVAILABLE[j];

i=s;

do

{if（FINISH[i]==FALSE&

&

=WORK）

{

WORK=WORK+ALLOCATION[i][j];

FINISH[i]=TRUE;

i=0;

}else

{i++;

}

}while（i<

M）;

if（FINISH[i]==FALSE）

{return1;

}return0;

intchkmax（ints）

{intj,flag=0;

if（MAX[s][j]==ALLOCATION[s][j]）

{flag=1;

AVAILABLE[j]=AVAILABLE[j]+MAX[s][j];

MAX[s][j]=0;

}

}returnflag;

voidbank（）

inti=0,j=0;

charflag='

Y'

while（flag=='

||flag=='

y'

）

i=-1;

while（i<

0||i>

请输入需申请资源的进程号（从P0到P"

M-1<

，否则重新输入!

）:

p"

cin>

i;

if（i<

=M）

cout<

输入的进程号不存在，重新输入!

请输入进程P"

申请的资源数:

{cout<

Request[j];

if（Request[j]>

NEED[i][j]）

{cout<

申请的资源数大于进程P"

还需要"

类资源的资源量!

申请不合理，出错!

请重新选择!

flag='

N'

break;

}

else

{if（Request[j]>

AVAILABLE[j]）

{cout<

申请的资源数大于系统可用"

flag='

break;

}

if（flag=='

{changdata（i）;

if（chksec（i））

该分配会导致系统不安全!

!

本次资源申请不成功，不予分配!

restoredata（i）;

else

经安全性检查，系统安全，本次分配成功，且资源分配状况如下所示：

showdata（）;

if（chkmax（i））

{cout<

在资源分配成功之后，由于该进程所需的某些资源的最大需求量已经满足，"

因此在进程结束后系统将回收这些资源！

在资源收回之后，各进程的资源需求和分配情况如下所示：

showdata（）;

}

}

是否继续银行家算法演示,按'

或'

键继续,按'

n'

键退出演示:

flag;

六、总结