实验三死锁的检测和解除

合集下载

死锁进程实验报告

死锁进程实验报告

死锁进程实验报告一、实验目的:观察死锁发生的现象,了解死锁发生的原因。

掌握如何判断死锁发生的方法。

二、实验分析:死锁现象是操作系统各个进程竞争系统中有限的资源引起的。

如果随机给进程分配资源,就可能发生死锁,因此就应有办法检测死锁的发生。

本次实验中采用“银行家算法”判断死锁的发生。

三、实验设计:本实验设计一个3个并发进程共享3种系统资源且每种系统资源有10个的系统。

系统能显示各种进程的进展情况以及检察是否有错误和死锁现象产生。

四、算法说明:“银行家算法”。

按每个进程的申请数量给各个进程试探性分配资源,看能否找个一个序列使各个进程都能正常运行结束。

若能,则不会发生死锁;若不能,则会发生死锁。

五、程序使用说明:一、本程序用于检测错误和是否会发生死锁。

系统有3个进程竞争3种系统资源,每种资源有10个。

二、输入各个进程的最大需求资源数目数组max[3]和已经得到的资源数目组[3],系统计算出各个进程还应申请的资源数目数组need[3]。

三、若进程最大需求数大于系统资源数(10),则出错;若进程申请的资源数目大于其需要的最大资源数目,则出错。

/*死锁实验源程序*/include<math.h>include<stdio.h>typedef struct{int state;int max[3];int alloc[3];int need[3];}Pc;int whefinish(Pc *p){if((p[0].state&&p[1].state&&p[2].state)==1) return 1;else return 0;}inpalloc(Pc *P,int *q1,int *q2){int m,n;for(m=0;m<3;m++)for(n=0;n<3;n++){scanf("%d",&p[m].alloc[n])p[m].need[n]=p[m].max[n]-p[m].alloc[n];q1[n]=q1[n]-p[m].alloc[n];if(p[m].need[n]>p[m].max[n])q2[n]=0;}Prlcess(Pcb *p1,int *p2,int *q){if(p1->need[0]<p2[0]&&p1->need[1]<p2[1]&&p1->need[2]<p2[2]) {P->state=0;p2[0]+=P->alloc[0];p2[1]+=p->alloc[1];p2[2]+=p->alloc[2];*p=3;}}main(){int i,j,n,x=0;int state[3],avil[3]={10,10,10}Pc pcb[3];for(i=0;i<3;i++)for(j=0;j<3;j++){scanf("%d",Pcb[i].max[j];if(Pcb[i].max[j]>10)state[i]=0;}if((state[0]&&state[1]&&state[2])==0) printf("error!\n");else{inpalloc(&Pcb,&avil[3],&state[3]);if((state[0]&&state[1]&&state[2])==0) printf("Error!\n");else{for(i=0;i<3;i++)for(j=0;j<3;j++)Process(&Pcb[j],&avil,&j);if(whefinish(&Pcb)==1)printf("all Pcbs are finishde!\n");else printf("Deally-Embrace!\n");}}}六、实验心得:通过这次实验使我对死锁的概念,死锁产生的原因,死锁是否会产生的判断算法,银行家算法,都有了更为深入和直观的了解以及掌握。

死锁的检测与解除

死锁的检测与解除
{ int flag;
flag=check(work,request,allocation,finish,p,m, n); //判断
if(flag==TRUE) { cout<<"不会发生死锁!"<<endl; }
else
{
cout<<"会发生死锁!死锁进程如下:"<<endl;
{
finish[i]=FALSE;
}
}
}
for(j=0;j<n;j++)
{
work[j]=available[j]; //初始情况
}
p[i]=TRUE; //第i个进程放完资源
flag=TRUE;
break;
}
}
}
//********若所有的进程都放完,则返回ture,否则返回false**************
judge(work,request,allocation,finish,p,m,n); //开始判断
}
for(i=0;i<m;i++){
finish[i]=TRUE; //初始标记为true
for(j=0;j<n;j++)
{
if(allocation[i][j]>0||request[i][j]>0)
cout<<"max["<<i<<"]["<<j<<"]:";
cin>>max[i][j];

实验三 死锁的检测与避免

实验三 死锁的检测与避免

实验三死锁的检测与避免1.实验目的通过本实验,使学生进一步了解死锁、系统安全与不安全和资源动态分配的概念,学会编程实现银行家算法检验系统状态是否安全的方法,从而为将来在实际系统中使用该方法打下基础。

2.实验内容1.输入并显示资源类型数,进程数,每类资源的个体数;2.输入每个进程对每类资源的最大需求量,已分量,算出其剩余需求量。

算出系统每类资源的当前剩余量;显示输入和计算出的数据;3.按银行家算法检测系统当前是否处于安全状态,若是,往下;若否,转1,重新设置数据;4.给出某个进程的资源分配请求,按死锁避免方法检测可否将资源分配给它?若可,输出一个进程安全序列、资源分配成功的说明和新的系统资源分配状态表;若否,输出“资源分配失败”和失败的原因:①,申请量大于系统的当前剩余量,②,申请量大于自己的剩余需求量,③,若分配系统将处于不安全状态。

4.实验方法和步骤(含设计)初始化算法流程图:银行家算法流程图:安全性算法流程图:源代码:#include<iostream>using namespace std;#define MAXPROCESS 50 //最大进程数#define MAXRESOURCE 100 //最大资源数int AVAILABLE[MAXRESOURCE]; //可用资源数组int MAX[MAXPROCESS][MAXRESOURCE]; //最大需求矩阵int ALLOCATION[MAXPROCESS][MAXRESOURCE]; //分配矩阵int NEED[MAXPROCESS][MAXRESOURCE]; //需求矩阵intREQUEST[MAXPROCESS][MAXRESOURCE]; //进程需要资源数bool FINISH[MAXPROCESS]; //系统是否有足够的资源分配int p[MAXPROCESS]; //记录序列int m,n; //m个进程,n个资源void Init();bool Safe();void Bank();int main(){ Init();//初始化函数Safe();//安全性检测函数Bank();//银行家算法 }void Init(){ int i,j;cout<<"请输入进程的数目:";cin>>m;cout<<"请输入资源的种类:";cin>>n;cout<<"请输入每个进程最多所需的各资源数,按照"<<m<<"x"<<n<<"矩阵输入"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>MAX[i][j];cout<<"请输入每个进程已分配的各资源数,也按照"<<m<<"x"<<n<<"矩阵输入"<<endl;for(i=0;i<m;i++){ for(j=0;j<n;j++){ cin>>ALLOCATION[i][j];NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];if(NEED[i][j]<0){cout<<"您输入的第"<<i+1<<"个进程所拥有的第"<<j+1<<"个资源数错误,请重新输入:"<<endl;j--; continue; } } }cout<<"请输入各个资源现有的数目:"<<endl;for(i=0;i<n;i++){ cin>>AVAILABLE[i];}}void Bank(){ int i,cusneed;char again;while(1){cout<<"请输入要申请资源的进程号(注:第1个进程号为0,依次类推)"<<endl; cin>>cusneed;cout<<"请输入进程所请求的各资源的数量"<<endl;for(i=0;i<n;i++){ cin>>REQUEST[cusneed][i];}for(i=0;i<n;i++){ if(REQUEST[cusneed][i]>NEED[cusneed][i]){ cout<<"您输入的请求数超过进程的需求量!请重新输入!"<<endl;continue;}if(REQUEST[cusneed][i]>AVAILABLE[i]){ cout<<"您输入的请求数超过系统有的资源数!请重新输入!"<<endl;continue;}}for(i=0;i<n;i++){ AVAILABLE[i]-=REQUEST[cusneed][i];ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];NEED[cusneed][i]-=REQUEST[cusneed][i]; }if(Safe()){ cout<<"同意分配请求!"<<endl;}else{ cout<<"您的请求被拒绝!"<<endl;for(i=0;i<n;i++){ AVAILABLE[i]+=REQUEST[cusneed][i];ALLOCATION[cusneed][i]-=REQUEST[cusneed][i];NEED[cusneed][i]+=REQUEST[cusneed][i];} }for(i=0;i<m;i++){ FINISH[i]=false;}cout<<"您还想再次请求分配吗?是请按y/Y,否请按其它键"<<endl;cin>>again;if(again=='y'||again=='Y'){ continue;} break; }}bool Safe(){ int i,j,k,l=0;int Work[MAXRESOURCE]; /*工作数组*/for(i=0;i<n;i++) Work[i]=AVAILABLE[i];for(i=0;i<m;i++){ FINISH[i]=false;}for(i=0;i<m;i++){if(FINISH[i]==true){ continue;}else{ for(j=0;j<n;j++){ if(NEED[i][j]>Work[j]){ break;} }if(j==n){ FINISH[i]=true; for(k=0;k<n;k++){ Work[k]+=ALLOCATION[i][k];} p[l++]=i; i=-1;}else{ continue; } }if(l==m){ cout<<"系统是安全的"<<endl;cout<<"安全序列:"<<endl;for(i=0;i<l;i++){ cout<<p[i];if(i!=l-1){ cout<<"-->"; } }cout<<""<<endl;return true;} }cout<<"系统是不安全的"<<endl;return false; }数据结构设计:1.可利用资源向量矩阵AVAILABLE。

死锁的检测与解除C语言代码

死锁的检测与解除C语言代码

if(i>0)
break;
printf("%2d",available[j]);
}
printf("\n");
}
}
主要数据结构
和银行家算法类似,需要建立相应的数组 int allocation[M][M]; int request[M][M]; int available[M]; int line[M]; //管理不占用资源的进程 int no[M]; //记录造成死锁的进程 int work[M];
流程图

开始 输入总进程
数 输入资源数
输入 Allocation 矩阵
输入 Request 矩阵
输入 available 矩阵
是否发生死锁 是
死锁解除
结束
运行结果
图(1)不会发生死锁时 图(1)当发生死锁时
附录
源代码如下:
# include "stdio.h" # define M 50 int allocation[M][M]; int request[M][M]; int available[M]; int line[M]; int no[M]; int n,m,i,j,f,a=0; main() {
if(f==0) { printf("该系统将发生死锁!\n");
printf("造成死锁的进程为:"); for(i=0;i<n;i++) printf("%2d",no[i]); printf("\n"); remove(); show(); } else{ printf("不会发生死锁!\n"); }

死锁实验报告

死锁实验报告

操作系统实验二报告一.实验名称:死锁的检测与解除二.实验目的:观察死锁产生的条件,并使用适当的算法,有效的防止和避免死锁的发生。

三.实验内容:死锁的检测算法:1.找出不再申请资源的进程,将它们所占的资源与系统中还剩余的资源加在一起作为“可分配的资源”,同时对这些进程置标志;2.检测所有无标志的进程,找出一个所需资源量不超过“可分配的资源”量的进程,将其所占用的资源添加到“可分配的资源”中,同时为该进程置标志;重复2)直到所有进程均有标志或无标志的进程的所需资源量均超过“可分配的资源”量;3.若进程均有标志,说明系统当前不存在死锁;若存在无标志的进程,则表示系统当前已有死锁形成,这些无标志的进程就是一组处于死锁状态的进程。

死锁的解除:当死锁检测程序检测到有死锁存在时,一般采用两种方式来解除死锁:1.终止进程:终止一个或多个涉及死锁的进程的执行,收回它们所占的资源再分配。

2.抢夺资源:从涉及死锁的一个或几个进程中抢夺资源,把夺来的资源再分配给卷入死锁的其他进程,直到死锁解除。

四.实验代码:#include <iostream>using namespace std;其中系统可用资源数为 2 1 0 0给进程3 分配资源数0 1 0 0六.实验心得:加深理解了有关资源申请分配、检测以及避免死锁等概念,了解死锁和避免死锁的具体实施方法。

死锁的解除实质上就是如何让释放资源的进程能够继续运行.为了解除死锁就要剥夺资源,此时,需要考虑一下几个问题:选择一个牺牲进程,即要剥夺哪个进程的哪些资源剥夺的进程如何再次运行.怎样保证不发生”饿死”现象“最小代价”,即最经济合算的算法,使得进程回退带来的开销最小.但是,”最小开销”是很不精确的,进程重新运行的开销包括很多因素:进程的优先级、该进程使用的资源种类和数量为完成任务,进程还需要多少资源有多少进程要被撤销、该进程被重新启动运行的次数.。

只有综合考虑各个进程之间的关系,跟资源的关系,才能搞好的解除死锁。

数据库死锁的检测与解决策略(一)

数据库死锁的检测与解决策略(一)

数据库死锁的检测与解决策略引言在现代科技快速发展的时代,数据库系统扮演着非常重要的角色,它们用于存储和管理大量的数据。

然而,在多用户环境下,数据库死锁成为了一个普遍存在的问题。

本文将探讨数据库死锁的检测与解决策略,帮助读者了解如何优化数据库系统的性能和可靠性。

一、数据库死锁的定义数据库死锁指的是多个事务同时请求数据库中的资源,但由于资源的互斥使用,导致彼此之间无法继续进行。

这种情况下,数据库系统就进入了一个死锁的状态。

二、数据库死锁的检测方法1. 图论算法图论算法是一种经典的死锁检测方法。

它通过构建和分析事务之间的资源依赖关系图来判断是否存在死锁。

如果图中存在一个循环路径,即表示存在死锁。

2. 等待图算法等待图算法也是一种常用的死锁检测方法。

它通过构建和分析等待图来判断是否存在死锁。

等待图中的节点表示事务,边表示等待关系。

如果存在一个闭合环,即表示存在死锁。

三、数据库死锁的解决策略1. 死锁预防死锁预防是一种在设计阶段已经采取的策略,目的是防止死锁的发生。

其中,最常用的方法是资源顺序分配法。

通过对多个资源设置一个固定的分配顺序,保证每个事务按照相同的顺序请求资源,从而避免死锁的发生。

2. 死锁避免死锁避免是一种动态的策略,根据系统的当前状态来判断是否允许某个事务继续执行。

银行家算法是常用的死锁避免算法之一。

在银行家算法中,系统根据当前的资源分配情况,判断是否存在安全序列。

如果存在安全序列,则事务可以继续执行,否则将被阻塞。

3. 死锁检测与解除死锁检测与解除是一种被动的策略,通过定期检测死锁的存在并采取相应的解锁操作。

常见的方法有超时检测和资源剥夺。

超时检测是指设置一个时间阈值,如果某个事务在一段时间内无法获取所需的资源,则判定为死锁,需要解除。

资源剥夺是指当一个事务请求某个资源时,如果该资源已经被其他事务占用,系统会临时中断其他事务的资源,将资源分配给当前请求事务,以避免死锁。

四、数据库死锁实例分析在一个银行系统中,存在两个事务,分别是转账事务和提现事务。

死锁的检测和预防

死锁的检测和预防

实验三:死锁的检测和预防一、实验目的1、进一步了解进程的并发执行。

2、加强对进程死锁的理解3、是用银行家算法完成死锁检测二、实验内容给出进程需求矩阵、资源向量以及一个进程的申请序列。

使用进程启动拒绝和资源分配拒绝(银行家算法)模拟该进程组的执行情况。

要求:初始状态没有进程启动计算每次进程申请是否分配?如:计算出预分配后的状态情况(安全状态、不安全状态),如果是安全状态,输出安全序列。

每次进程申请被允许后,输出资源分配矩阵A和可用资源向量V。

每次申请情况应可单步查看,如:输入一个空格,继续下个申请三、实验环境VC++四、实验原理及实验思路1、安全状态:如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态。

安全状态一定是没有死锁发生。

2、不安全状态:不存在一个安全序列。

不安全状态一定导致死锁。

安全序列:一个进程序列{P1,…,Pn}是安全的,如果对于每一个进程Pi(1≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。

3、银行家算法:把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。

操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。

当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。

若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量,若能满足则按当前的申请量分配资源,否则也要推迟分配。

4、银行家算法的思路:1.进程一开始向系统提出最大需求量.2.进程每次提出新的需求(分期贷款)都统计是否超出它事先提出的最大需求量.3.若正常,则判断该进程所需剩余剩余量(包括本次申请)是否超出系统所掌握的剩余资源量,若不超出,则分配,否则等待.5、银行家算法的数据结构:1.系统剩余资源量A[n],其中A[n]表示第I类资源剩余量.2.各进程最大需求量,B[m][n],其中B[j][i]表示进程j对i类资源最大需求.3.已分配资源量C[m][n],其中C[j][i]表示系统j程已得到的第i资源的数量.4.剩余需求量.D[m][n],其中D[j][i]对第i资源尚需的数目.五、流程图银行家算法:安全检测:六、源代码#include "string.h"#include <stdio.h>#include <stdlib.h>#define M 5#define N 3#define FALSE 0#define TRUE 1/*M个进程对N类资源最大资源需求量*/int MAX[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};/*系统可用资源数*/int AVAILABLE[N]={10,5,7};/*M个进程对N类资源最大资源需求量*/int ALLOCATION[M][N]={{0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0}};/*M个进程还需要N类资源的资源量*/int NEED[M][N]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};/*M个进程还需要N类资源的资源量*/int Request[N]={0,0,0};void main(){int i=0,j=0;char flag='Y';char finishFlag='Y';void showdata();void changdata(int);void rstordata(int);int chkerr(int);showdata();while(finishFlag=='Y'||finishFlag=='y') //可以分配资源{i=-1;while(i<0||i>=M) //判断申请的资源号是否有效{printf("请输入需申请资源的进程号(从0到%d,否则重输入!):",M-1);scanf("%d",&i);if(i<0||i>=M)printf("输入的进程号不存在,重新输入!\n");}printf("请输入进程%d申请的资源数\n",i);for (j=0;j<N;j++){printf("资源%d:",j);scanf("%d",&Request[j]);if(Request[j]>NEED[i][j]) //进程申请资源数大于进程还需要的资源{printf("进程%d申请的资源数大于进程%d还需要%d类资源的资源量!申请不合理,出错!请重新选择!\n",i,i,j);flag='N';break;}else{if(Request[j]>AVAILABLE[j]) //进程申请资源数大于系统可用该类资源量{printf("进程%d申请的资源数大于系统可用%d类资源的资源量!申请不合理,出错!请重新选择!\n",i,j);flag='N';break;}}}if(flag=='Y'||flag=='y'){int result;changdata(i);result=chkerr(i);if(result==1){rstordata(i);showdata();}elseshowdata();}//else//showdata();printf("\n");printf("是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ");getchar();scanf("%c",&finishFlag);}}void showdata() //显示各类资源的分配情况{int i,j;printf("系统可用的资源数为:\n");printf(" ");for (j=0;j<N;j++){printf(" 资源%d:%d ",j,AVAILABLE[j]);}printf("\n");printf("各进程还需要的资源量:\n");for (i=0;i<M;i++){printf(" 进程%d ",i);for (j=0;j<N;j++){printf("资源%d:%d ",j,NEED[i][j]);}printf("\n");}printf("各进程已经得到的资源量: \n");for (i=0;i<M;i++){printf(" 进程%d ",i);for (j=0;j<N;j++)printf("资源%d:%d ",j,ALLOCATION[i][j]);printf("\n");}}void changdata(int k){int j;for (j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]-Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];NEED[k][j]=NEED[k][j]-Request[j];}}void rstordata(int k){int j;for (j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]+Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];NEED[k][j]=NEED[k][j]+Request[j];}}int chkerr(int s) //检查是否能够分配该资源{int WORK,FINISH[M],temp[M];int i,j,k=0;for(i=0;i<M;i++)FINISH[i]=FALSE;for(j=0;j<N;j++){WORK=AVAILABLE[j];i=s;while(i<M){if (FINISH[i]==FALSE&&NEED[i][j]<=WORK){WORK=WORK+ALLOCATION[i][j];FINISH[i]=TRUE;temp[k]=i;k++;i=0;}else{i++;}}for(i=0;i<M;i++)if(FINISH[i]==FALSE){printf("\n系统不安全!!! 本次资源申请不成功!!!\n\n");return 1;}}printf("\n经安全性检查,系统安全,本次分配成功。

死锁的检测与解除

死锁的检测与解除

操作系统(实验报告)死锁的检测与解除姓名:*****学号:****专业班级:***学验日期:2011/12/2指导老师:***一、实验名称:死锁的检测和解除二、实验内容:编程实现对操作系统死锁的检测和解除,利用数据的动态输入,解锁时采用的是释放占用系统资源最大的进程的方法来实现。

三、实验目的:熟悉死锁检测与的解除的算法,深入理解死锁的检测与解锁的具体方法,加深对死锁问题深刻记意。

并且进一步掌握死锁的条件,死锁定理等相关知识。

四、实验过程1.基本思想:利用资源分配图来理解此问题,可以认为此图就是由一组结点N和一组边E 所组成的一个对偶G=(N1E);把N分为互斥的两个子集进程P结点和资源R 结点,进程结点集和资源结点集,凡是属于E中的一个边,都连接着P中的一个结点和R中的一个结点由P中的一个结点指向R中的一个结点是资源请求边,而由R中的一个结点指向P中的一个结点的边称为资源分配边,在这个图中找到一个既不阻塞又不独立的结点Pi,如果是在顺利的情况下,则该进程可以获得足够资源而继续运行,运行完释放所有资源,这就可以说是消除了它的请求边和分配边,让它成为一个孤立的点,再继续,分配给请求资源的进程……这样循环下去直到所有的进程都能成为孤立的点,或是出现了无法消除的环状,若是出现了环状,即出现了死锁,采取释放占用资源最多的进程的方法来解决问题,直到最后所有的进程结点P均成为孤立的点。

解锁才算成功,程序才能结束。

2.主要数据结构:(1)可利用资源向量Available.这是一个含有m类资源的数组,用来表示每种资源可用的的数量。

(2)把不占用任何资源,且没有申请资源的进程,列入数组finish中,并赋值true。

(3)从进程集合中找到一个Request<=Work的进程,做如下的处理:将其资源分配图简化,释放出资源,增加Work的量,做Work=Work+Allocation 并将它的标志位finish也设为true.(4)如果不能把所有的进程标志位都赋值为true,则出现了死锁,开始采取解锁的方案。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

南华大学计算机科学与技术学院实验报告课程名称操作系统I 姓名学号专业班级任课教师日期一、实验内容死锁的检测与解除二、实验目的掌握操作系统的进程管理与资源分配原理,掌握对操作系统安全性检验和死锁的解除的原理和方法。

三、实验题目系统中有 m 个同类资源被 n 个进程共享,每个进程对资源的最大需求数分别为 S1,S2,…,Sn,且 Max(Si)<=m, (i=1,2,…n)。

进程可以动态地申请资源和释放资源。

编写一个程序,实现银行家算法,当系统将资源分配给某一进程而不会死锁时,就分配之。

否则,推迟分配,并显示适当的信息。

分别使用检测“进程—资源循环等待链”的方法和 Coffman 的算法来检测进程的死锁状态。

对于相同的进程资源分配、占用次序,比较两个算法的结果。

四、设计思路和流程图1.输入系统进程数量n和资源类型数量m。

2.输入每类资源的数量。

3.输入每个进程每类资源的最大需求量和已获资源量。

4.检验系统的安全。

5.若检测结果为系统不安全,可以对死锁进行解除,直到安全为止再检测。

6.重复5操作,直到所有进程运行完毕。

五、主要数据结构及其说明int Max[100][100]={0}; //各进程所需各类资源的最大需求; int Available[100]={0}; //系统可用资源;char Name[100]={0}; //资源的名称;int Allocation[100][100]={0}; //系统已分配资源;int Need[100][100]={0}; //还需要资源int Request[100]={0}; //请求资源向量;int Temp[100]={0}; //存放安全序列;int Work[100]={0}; //存放系统可提供资源;bool Finish[100]={0};//存放已完成的序列六、源程序并附上注释#include "stdafx.h"#include<iostream>#define False 0#define True 1using namespace std;int Max[100][100]={0}; //各进程所需各类资源的最大需求; int Available[100]={0}; //系统可用资源;char Name[100]={0}; //资源的名称;int Allocation[100][100]={0}; //系统已分配资源;int Need[100][100]={0}; //还需要资源int Request[100]={0}; //请求资源向量;int Temp[100]={0}; //存放安全序列;int Work[100]={0}; //存放系统可提供资源;bool Finish[100]={0};int M=100; //作业的最大数int N=100; //资源的最大数int l=0;//记录安全进程的TEMP下标void ShowData()//初始化资源矩阵{int i,j;cout<<"系统可用资源[Available]:"<<endl;for(i=0;i<N;i++)cout<<Name[i]<<" ";cout<<endl;for(j=0;j<N;j++)cout<<Available[j]<<" ";//显示可分配的资源cout<<endl;cout<<" Max Allocation Need"<<endl;cout<<"进程名 ";for (j=0;j<3;j++)//MAX ALLOCATION NEED 共列{for (i=0;i<N;i++){cout<<Name[i]<<" ";}cout<<" ";} cout<<endl;for(i=0;i<M;i++){cout<<" "<<i<<" ";//输出进程名for(j=0;j<N;j++)cout<<Max[i][j]<<" ";//输出最大cout<<" ";for(j=0;j<N;j++)cout<<Allocation[i][j]<<" ";//输出已分配cout<<" ";for(j=0;j<N;j++)cout<<Need[i][j]<<" ";//输出需求cout<<endl;}}bool Safe() //安全性算法{int i,j,k;for(i=0;i<N;i++)Work[i]=Available[i]; //初始化工作向量for(i=0;i<M;i++){Finish[i]=false; //判断进程i是否已执行}for(i=0;i<M;i++){if(Finish[i]==true){continue;} else{for(j=0;j<N;j++) //验证每一个资源的需求量是否小于可用资源量 {if(Need[i][j]>Work[j]){break;}}if(j==N)//若Need都小于Work{Finish[i]=true;for(k=0;k<N;k++){Work[k]+=Allocation[i][k]; //进程i执行完后回收资源 }Temp[l++]=i;i=-1;}else{continue;}}if(l==M){cout<<"系统是安全的"<<endl;cout<<"安全序列:"<<endl;for(i=0;i<l;i++){cout<<Temp[i];if(i!=l-1){cout<<"-->";}}cout<<""<<endl;return true;}}for(i=0;i<M;i++)if(Finish[i]==false)cout<<"会发生死锁,发生死锁的进程是:"<<i<<" "<<endl;cout<<endl;return false;}void unlock(){int i,j;i=0;cout<<"死锁解除开始";cout<<endl;while(i<M&&Finish[i]==false) //查找未完成的进程{for(j=0;j<N;j++){Available[j]+=Allocation[i][j]; //回收该进程所有资源Allocation[i][j]=0;}if(Safe())cout<<"死锁已解除"<<endl;elsei++;//到下一个进程Safe();}}int main(){int i,j,number,m,n,flag;int over;char mc;cout<<"--------------------------死锁的检测与解除----------------------------------";cout<<endl;cout<<endl;cout<<"输入当前系统可供使用资源种类的数量:";cin>>n;N=n;for (i=0;i<n;i++){cout<<"资源"<<i+1<<"的名称:";cin>>mc;Name[i]=mc;cout<<"资源"<<i+1<<"的数量:";cin>>number;Available[i]=number;cout<<endl;}cout<<endl;cout<<"请输入作业的数量:";cin>>m;M=m;cout<<"请输入各进程的最大需求量("<<m<<"*"<<n<<"矩阵)[Max]:"<<endl;for (int i=0;i<m;i++)for (int j=0;j<n;j++){cin>>Max[i][j];}do{flag=0;cout<<"请输入各进程已经分配资源量("<<m<<"*"<<n<<"矩阵)[Allocation]:"<<endl;for (int i=0;i<m;i++)for (j=0;j<n;j++){cin>>Allocation[i][j];if(Allocation[i][j]>Max[i][j])flag=1;Need[i][j]=Max[i][j]-Allocation[i][j];}if(flag)cout<<"首次输入的已分配资源已经大于最大需求量请重新输入!\n";}while(flag);// 当申请资源符合要求时end doShowData();//显示Safe();//安全检测if(l!=m)//当安全进程数不等于所有进程数unlock();cout<<"运行结束"<<endl;cin>>over;}七、程序运行时的初值和运行结果八、实验体会通过本次实验,比较完整的掌握了操作系统的进程管理与资源分配原理,以及对操作系统安全性检验和死锁的解除的原理和方法。

相关文档
最新文档