银行家算法实验报告

合集下载

银行家算法实验报告总结

银行家算法实验报告总结

银行家算法实验报告总结一、实验目的与背景银行家算法是一种用于避免死锁和保证系统稳定运行的算法。

通过模拟银行贷款行为的策略,银行家算法可以有效地避免系统的资源枯竭,从而保证系统的正常运行。

在本实验中,我们通过使用银行家算法对实际的系统进行模拟,验证其有效性。

二、算法原理与流程银行家算法的主要原理是:将系统中的所有资源按照类型进行分类,并对每种资源设置一个最大值和最小值,分别表示该资源的最大需求量和最小剩余量。

同时,对于每个进程,需要定义其最大需求量、已分配资源和需求量,并根据这些信息来决定是否分配资源。

具体流程如下:初始化:将所有资源的最大值和最小值进行初始化,并给每个进程分配一个唯一的标识符。

请求资源:每个进程在执行过程中,如果需要更多的资源,则向系统发送请求。

分配资源:系统根据银行家算法的原理,将资源分配给满足条件的进程。

更新资源:系统更新已分配给进程的资源,并检查是否满足每个进程的最大需求量。

重复执行:如果存在多个进程需要资源,则重复执行步骤2-4,直到所有进程都满足其最大需求量或系统中的资源不足以为更多的进程分配资源为止。

三、实验数据与结果在本实验中,我们使用了10个进程,每个进程的需求量和已分配资源均随机生成。

实验结果表明,在满足了每个进程的最大需求量后,系统中仍有剩余资源,证明了银行家算法可以有效地避免资源的浪费。

四、结果分析通过对实验结果进行分析,我们发现银行家算法可以有效地保证系统的稳定性,避免出现死锁和资源枯竭等问题。

同时,该算法需要较少的系统开销,因为只需要对每个进程的请求进行处理和更新,不需要进行额外的检查和管理。

五、性能对比分析为了进一步验证银行家算法的性能,我们将其与其他常见的资源管理算法进行了比较。

在同等条件下,与其他算法相比,银行家算法具有更高的系统吞吐量和更低的响应时间。

银行家算法在系统吞吐量和响应时间方面均优于其他常见算法,而在死锁发生率上,银行家算法则表现出了更高的稳定性。

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告银行家算法实验报告引言:在计算机科学领域中,银行家算法是一种用于避免死锁的资源分配算法。

它是由荷兰计算机科学家艾兹赫尔·迪科斯彻在1965年提出的。

银行家算法通过合理的资源分配和安全性检查,确保系统中的进程能够安全地执行,避免了资源竞争和死锁的发生。

本篇文章将详细介绍银行家算法的原理、实验设计和结果分析。

一、银行家算法的原理银行家算法基于资源的最大需求和可用性进行资源分配。

它将系统中的资源分为若干类别,并为每个类别分配一个初始数量。

当进程请求资源时,银行家算法会检查该请求是否能够满足,如果满足则分配资源,否则将进程置于等待状态。

算法的核心思想是避免分配资源后导致系统无法满足其他进程的资源需求,从而避免死锁的发生。

二、实验设计为了验证银行家算法的有效性,我们设计了一个模拟实验。

实验中,我们创建了一个包含多个进程和资源的系统,并模拟了进程对资源的请求和释放。

每个进程都有自己的资源需求和最大需求量,系统中的资源总量也是有限的。

首先,我们初始化系统的资源数量和每个进程的最大需求量。

然后,模拟进程的请求和释放过程。

当一个进程请求资源时,银行家算法会检查该请求是否能够满足,如果满足则分配资源,否则将进程置于等待状态。

当一个进程释放资源时,系统将回收该资源并重新分配给其他进程。

实验的关键是设计合理的资源分配策略和进程请求顺序,以模拟不同的场景。

我们通过调整进程的最大需求量和资源数量,观察系统的运行情况和死锁的发生情况。

三、实验结果分析通过多次实验,我们得出了以下结论:1. 资源数量的合理分配对避免死锁非常重要。

如果资源数量过少,无法满足进程的最大需求量,系统容易发生死锁。

如果资源数量过多,系统的资源利用率低,效率低下。

因此,需要根据系统的实际需求合理分配资源数量。

2. 进程的最大需求量与资源数量的关系也是影响死锁的重要因素。

当进程的最大需求量超过系统资源数量的一半时,系统容易发生死锁。

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告银行家算法是为了实现避免出现死锁的状态而采取的一种算法,本实验则是用C语言实现。

一、银行家算法数据结构1、可利用资源数量Avail。

这是一个含M个元素的数组,其中每一个元素代表一类可用的资源数目,定义为int型,Avail[m]。

2、最大需求矩阵Max。

这是一个nxm的二维矩阵,它定义了系统中n个进程的每一个进程对m类资源的最大需求,定义为int型,Max[n][m]。

3、分配矩阵Alloc。

这是一个nxm的二维矩阵,它定义了系统中每一类资源当前已分配给每一进程的资源数。

定义为int型,Alloc[n][m]。

4、需求矩阵Need。

这也是一个nxm的二维矩阵,用以表示每一个进程尚需的各类资源数。

定义为int型,Need[n][m]。

5、请求资源数目Request。

这是一个含M个元素的数组,它表示进程请求的资源数目,定义为int型,Request[m]。

6、系统当前可用的资源矩阵Work,这是一个含M个元素的数组,表示系统还可以分配的资源数目,用于对安全算法的检测。

定义为int型,Work[m]。

7、记录安全序号的数组sequence,用于记录系统的安全信号,便于在后面输出。

定义为int型,sequence[n].二、银行家算法过程步骤如下:1、判断请求的资源是否超过他所宣布需要的最大值,即如果request[j]>need[i][j],则判断出错,否则继续执行。

2、判断请求的资源是否超过系统可分配的数目,即如果request[j]>Avail[j],则判断出错,否则继续执行。

3、系统试探着把资源分配给进程Pi。

并修改其中的数据Avail、Alloc、Need。

4、系统进行安全性算法的检查。

三、安全性算法其中有两个信号量,Work和Finish。

分别用于表示系统可提供给进程的继续运行所需的各类资源的数目,含m个int型的元素。

而Finish用于标识系统是否有足够的资源分配给进程,使之运行完成,默认为1(不能),从而只有在finish都为0时才能表示安全算法成功。

民大-银行家算法-操作系统实验报告

民大-银行家算法-操作系统实验报告

银行家算法实验报告一、实验题目为了了解系统的资源分配情况,假定系统的任何一种资源在任一种资源在任意时刻只能被一个进程使用。

任何进程已经占用的资源只能由进程自己释放,而不能任由其他进程抢占。

当进程申请的资源不能满足时,必须等待。

因此,只要资源分配算法能保证进程的资源请求,且不出现循环等待,则系统不会出现死锁。

而银行家算法是避免死锁的一种重要方法。

通过编写一个模拟动态资源分配的银行家算法程序,进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念,并掌握避免死锁的具体实施方法二、实验要求要求编写系统进行资源调度的程序,模拟进程的资源分配算法,了解死锁的产生和避免的办法。

一个是随机动态地进行资源分配的模拟程序,即只要系统当前剩余资源满足进程的当前要求,就立即将资源分配给进程,以观察死锁产生情况;一个是采用银行家算法,有效地避免死锁的产生。

要求用银行家算法和随机算法实现资源分配。

1.设计3-4个并发进程,共享系统的10个同类不可抢占的资源。

各进程动态进行资源的申请和释放。

2.用银行家算法和随机算法分别设计一个资源分配程序,运行这两个程序,观察系统运行情况,并对系统运行的每一步情况进行显示。

二、总的设计思想及语言环境、工具等1.算法设计思路银行家算法又称“资源分配拒绝”法,其基本思想是,系统中的所有进程放入进程集合,在安全状态下系统受到进程的请求后试探性的把资源分配给他,现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较,找出剩余资源能满足最大需求量的进程,从而保证进程运行完成后还回全部资源。

这时系统将该进程从进程集合中将其清除。

此时系统中的资源就更多了。

反复执行上面的步骤,最后检查进程的集合为空时就表明本次申请可行,系统处于安全状态,可以实施本次分配,否则,只要进程集合非空,系统便处于不安全状态,本次不能分配给他,请进程等待。

2.语言环境、工具计算机基本配置要求:操作系统:WIN 98/2000/XP/2003 等Windows平台内存:256MB及以上主存64KB(Memory)(以KB为单位分配)开发语言:Visual C++ 6.0四、数据结构与模块说明(功能与框图)五、源程序(指导老师验收通过)#include<string.h>#include<iostream.h>#define FALSE 0#define TRUE 1#define W 10 //最大进程数W=10#define R 20 //最大资源总数R=20int M ;int N ;int ALL_RESOURCE[W];int AVAILABLE[R]; //可利用资源向量int MAX[W][R]; //最大需求矩阵int ALLOCATION[W][R]; //分配矩阵int NEED[W][R]; //需求矩阵int Request[R]; //进程请求向量void inputdata(); //数据输入void showdata(); //数据显示void changdata(int k);//进程请求资源数据改变void restoredata(int k); //数据恢复int chksec(int s); //系统安全性的检测int chkmax(int s); //检测最大需求void bank(); //检测分配的资源是否合理void main(){ int i,j;inputdata();for(i=0;i<M;i++){ j=chksec(i);if (j==0) break;}if (i>=M)cout<<"错误提示:经安全性检查发现,系统的初始状态不安全\n"<<endl;else{ cout<<"提示:经安全性检查发现,系统的初始状态安全!"<<endl;bank();}}void inputdata(){ int i=0,j=0,p;cout<<"请输入总进程数:"<<endl;do{cin>>M;if (M>W) cout<<endl<<"总进程数超过了程序允许的最大进程数,请重新输入:"<<endl;}while (M>W);cout<<endl;cout<<"请输入资源的种类数:"<<endl;do {cin>>N;if (N>R)cout<<endl<<"资源的种类数超过了程序允许的最大资源种类数,请重新输入:"<<endl; }while (N>R);cout<<endl;cout<<"请依次输入各类资源的总数量,即设置向量all_resource:"<<endl;for(i=0;i<N;i++) cin>>ALL_RESOURCE[i];cout<<endl;cout<<"请依次输入各进程所需要的最大资源数量,即设置矩阵max:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do { cin>>MAX[i][j];if (MAX[i][j]>ALL_RESOURCE[j])cout<<endl<<"该最大资源数量超过了声明的该资源总数,请重新输入:"<<endl; }while (MAX[i][j]>ALL_RESOURCE[j]);}}cout<<endl;cout<<"请依次输入各进程已经占据的各类资源数量,即设置矩阵allocation:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do{ cin>>ALLOCATION[i][j];if (ALLOCATION[i][j]>MAX[i][j])cout<<endl<<"已占有的资源数量超过了声明的最大资源数量,请重新输入:"<<endl;}while (ALLOCATION[i][j]>MAX[i][j]);}}cout<<endl;for (i=0;i<M;i++)for(j=0;j<N;j++)NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];for (j=0;j<N;j++){ p=ALL_RESOURCE[j];for (i=0;i<M;i++){ p=p-ALLOCATION[i][j];AVAILABLE[j]=p;if(AVAILABLE[j]<0)AVAILABLE[j]=0;}}}void showdata(){ int i,j;cout<<"各种资源的总数量,即向量all_resource为:"<<endl;cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<ALL_RESOURCE[j];cout<<endl<<endl;cout<<"当前系统中各类资源的可用数量,即向量available为:"<<endl; cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<AVAILABLE[j];cout<<endl<<endl;cout<<"各进程还需要的资源数量,即矩阵need为:"<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<NEED[i][j]<<" ";cout<<endl;}cout<<endl;cout<<"各进程已经得到的资源量,即矩阵allocation为: "<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<ALLOCATION[i][j]<<" ";cout<<endl;} cout<<endl;}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 restoredata(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 chksec(int s){int WORK,FINISH[W];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;do{ if(FINISH[i]==FALSE&&NEED[i][j]<=WORK){WORK=WORK+ALLOCATION[i][j];FINISH[i]=TRUE;i=0;}else{ i++;}}while(i<M);for(i=0;i<M;i++)if(FINISH[i]==FALSE){ return 1;}} return 0;}int chkmax(int s){ int j,flag=0;for(j=0;j<N;j++){if (MAX[s][j]==ALLOCATION[s][j]){ flag=1;AVAILABLE[j]=AVAILABLE[j]+MAX[s][j];MAX[s][j]=0;}} return flag;}c{int i=0,j=0;char flag='Y';while(flag=='Y'||flag=='y'){i=-1;while(i<0||i>=M){ cout<<"请输入需申请资源的进程号(从P0到P"<<M-1<<",否则重新输入!):"; cout<<"p";cin>>i;if(i<0||i>=M)cout<<"输入的进程号不存在,重新输入!"<<endl;}cout<<"请输入进程P"<<i<<"申请的资源数:"<<endl;for (j=0;j<N;j++){ cout<<" 资源"<<j<<": ";cin>>Request[j];if(Request[j]>NEED[i][j]){ cout<<"进程P"<<i<<"申请的资源数大于进程P"<<i<<"还需要"<<j<<"类资源的资源量!";cout<<"申请不合理,出错!请重新选择!"<<endl<<endl;flag='N';break;}else{ if(Request[j]>AVAILABLE[j]){ cout<<"进程P"<<i<<"申请的资源数大于系统可用"<<j<<"类资源的资源量!";cout<<"申请不合理,出错!请重新选择!"<<endl<<endl;flag='N';break;}}}if(flag=='Y'||flag=='y'){ changdata(i);if(chksec(i)){ cout<<endl;cout<<"该分配会导致系统不安全本次资源申请不成功,不予分配"<<endl;cout<<endl;restoredata(i);}else{ cout<<endl;cout<<"经安全性检查,系统安全,本次分配成功,且资源分配状况如下所示:"<<endl;cout<<endl;showdata();if(chkmax(i)){cout<<"在资源分配成功之后,由于该进程所需的某些资源的最大需求量已经满足,"<<endl;cout<<"因此在进程结束后系统将回收这些资源!"<<endl;cout<<"在资源收回之后,各进程的资源需求和分配情况如下所示:"<<endl;showdata();}}}cout<<endl;cout<<" 是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ";cin>>flag; }}六、运行结果分析1.输入进程数、资源种类数、各类资源总数量、各进程所需要的最大资源数量、各进程所已经占据的各类资源数量2.经安全性检验,系统状态安全,进程P0申请资源3.经安全性检验,系统状态安全,进程P0获得所申请资源4.进程P3申请资源5.经安全性检验,系统状态安全,进程P3获得所申请资源6.进程P1申请资源7.经安全性检验,系统状态安全,进程P1获得所申请资源8.进程P2申请资源9.经安全性检验,系统状态安全,进程P2获得所申请资源5.进程P1申请资源6.经安全性检验,系统状态安全,进程P1获得所申请资源七、总结这次实验中我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。

银行家算法实验报告

银行家算法实验报告

计算机操作系统实验报告一、实验名称:银行家算法二、实验目的:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

三、问题分析与设计:1、算法思路:先对用户提出的请求进行合法性检查,即检查请求是否大于需要的,是否大于可利用的。

若请求合法,则进行预分配,对分配后的状态调用安全性算法进行检查。

若安全,则分配;若不安全,则拒绝申请,恢复到原来的状态,拒绝申请。

2、银行家算法步骤:(1)如果Requesti<or =Need,则转向步骤(2);否则,认为出错,因为它所需要的资源数已超过它所宣布的最大值。

(2)如果Request<or=Available,则转向步骤(3);否则,表示系统中尚无足够的资源,进程必须等待。

(3)系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值:Available=Available-Request[i];Allocation=Allocation+Request;Need=Need-Request;(4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。

3、安全性算法步骤:(1)设置两个向量①工作向量Work。

它表示系统可提供进程继续运行所需要的各类资源数目,执行安全算法开始时,Work=Allocation;②布尔向量Finish。

它表示系统是否有足够的资源分配给进程,使之运行完成,开始时先做Finish[i]=false,当有足够资源分配给进程时,令Finish[i]=true。

(2)从进程集合中找到一个能满足下述条件的进程:①Finish[i]=false②Need<or=Work如找到,执行步骤(3);否则,执行步骤(4)。

(3)当进程P获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:Work=Work+Allocation;Finish[i]=true;转向步骤(2)。

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告实验目的:了解和掌握银行家算法,进一步熟悉进程和如何避免死锁。

实验内容:1、主要程序结构(a)resource allocation algorithm如果要求的资源量+占有的资源总的资源需求量可以carry out allocation(b) test for safety algorithm注:《--- 》中的内容为未具体写明但说明其功能的程序段bool safe(struct state new ){bool possible = true,found=false;process rest[n];//正在执行的进程号int p=n;// 正在执行的进程数量int currentavail[m];//可用资源的一个副本《---为rest和currentavail赋值---》while(possible==true&&p>0){int g=0;《---寻找可以执行完成的进程---》if(found==true){int c=0;《---假设可以执行完的进程以完成,及currentavail[*]=currentavail[*]+new.alloc[g][*];---》rest[g] = -1;--p;found =false;}else{possible=false;}}return possible;}2、实验步骤1)设计结构体#ifndef STATE_H_#define m 3#define n 5struct state{int resource[m];int available[m];int claim[n][m];int alloc[n][m];} ;#define STATE_H_#endif /* STATE_H_ */2)设计实现程序的结构的具体程序Safe算法的具体代码bool safe(struct state new ){bool possible = true,found=false;process rest[n]; //正在执行的进程号int f=0,p=n;// 正在执行的进程数量do{rest[f]=f;++f;}while(f<n);int currentavail[m]; //可用资源的一个副本int i=0;do{currentavail[i]=new.available[i];++i;}while(i<m);while(possible==true&&p>0){int g=0;/*------------------寻找可以执行完成的进程------------------------------------------*/ while(g<n){int h = 0;/*while(h<m){if((new.claim[g][h]-new.alloc[g][h])<=currentavail[h]&&rest[g]!=(-1)){if(h==m-1){found=true;}}++h;}if(found==true)break;++g;}/*-------------------------------------------------------------------------------------*/ if(found==true){int c=0;while(c<m){currentavail[c]=currentavail[c]+new.alloc[g][c];c++;}rest[g] = -1;--p;found =false;}else{possible=false;}}return possible;}实验代码:/*============================================================================ Name : pre.cAuthor :Version :Copyright : Your copyright noticeDescription : Hello World in C, Ansi-style============================================================================ */#include <stdio.h>#include <stdlib.h>#include"state.h"#define bool int#define process int#define false 0#define true 1int main(void) {bool alloc(int,int[],struct state );struct state sta1={{10,5,7},{3,3,2},{{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}},{{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}}};int request[m];int k=0;while(k>=0){puts("输入要改变资源的进程号");scanf("%d",&k);puts("输入要改变的资源");int i =0;while(i<m){scanf("%d",&request[i]);i++;}if(alloc(k,request,sta1)==true){i=0;puts("输出个进程占用的资源");while(i<n){int j=0;printf("%d ",i);while(j<m){if(i==k){sta1.alloc[k][j]=request[j]+sta1.alloc[k][j];sta1.available[j]=sta1.available[j]-request[j];}printf("%d ",sta1.alloc[i][j]);j++;}printf("\n");++i;}}puts("银行家算法");}return 0;}bool alloc(int l,int request[m],struct state nest){bool safe(struct state news);bool t = false;int i=0;while(i<m){if(nest.alloc[l][i]+request[i]>nest.claim[l][i]){puts("!!resource request error!!");return false;}else if(request[i]>nest.available[i]){puts("suspend process");return false;}else{if(i==m-1){int f=0;while(f<m){nest.alloc[l][f]=nest.alloc[l][f]+request[f];nest.available[f]=nest.available[f]-request[f];f++;}if(safe(nest)==true){t=true;}else{puts(" no safe suspend process");t=false;}}}i++;}return t;}bool safe(struct state new ){bool possible = true,found=false;process rest[n];int f=0,p=n;do{rest[f]=f;++f;}while(f<n);int currentavail[m];int i=0;do{currentavail[i]=new.available[i];++i;}while(i<m);while(possible==true&&p>0){int g=0;while(g<n){int h = 0;while(h<m&&(new.claim[g][h]-new.alloc[g][h])<=currentavail[h]&&rest[g]!=(-1)){if(h==m-1){found=true;}++h;}if(found==true)break;++g;}if(found==true){int c=0;while(c<m){currentavail[c]=currentavail[c]+new.alloc[g][c];c++;}rest[g] = -1;--p;found =false;}else{possible=false;}}return possible;}。

银行家算法实验报告绪论

银行家算法实验报告绪论

一、实验背景在计算机系统中,资源分配和死锁问题是操作系统领域的重要研究课题。

在多进程环境下,进程之间会共享系统资源,如CPU、内存、磁盘等。

然而,当多个进程同时申请资源时,可能会出现死锁现象,导致系统瘫痪。

为了避免死锁,研究者提出了多种资源分配算法,其中最具代表性的就是银行家算法。

银行家算法最初由Edsger Dijkstra于1965年提出,旨在解决银行在贷款业务中可能出现的死锁问题。

该算法通过模拟银行家在贷款业务中的决策过程,对资源分配进行动态规划,以确保系统处于安全状态,从而避免死锁的发生。

二、实验目的本次实验旨在通过实现银行家算法,加深对资源分配、死锁和安全性概念的理解,并掌握以下内容:1. 了解资源分配的基本原理和死锁的概念。

2. 掌握银行家算法的原理和实现方法。

3. 能够运用银行家算法对系统资源进行动态分配,并确保系统处于安全状态。

4. 分析实验结果,验证银行家算法的有效性。

三、实验原理1. 资源分配资源分配是指操作系统将资源分配给进程的过程。

在多进程环境下,资源分配策略需要考虑以下因素:(1)资源的类型和数量。

(2)进程对资源的最大需求。

(3)进程当前已分配的资源。

(4)系统可利用的资源。

2. 死锁死锁是指多个进程在执行过程中,因争夺资源而相互等待,导致系统无法继续执行的现象。

产生死锁的必要条件包括:(1)互斥条件:资源不能被多个进程同时占用。

(2)请求和保持条件:进程在等待资源时,仍保持已占有的资源。

(3)不剥夺条件:进程不能被强制剥夺已占有的资源。

(4)循环等待条件:存在一个进程序列,其中每个进程都在等待前一个进程所持有的资源。

3. 安全状态安全状态是指系统可以按照某种顺序为每个进程分配资源,使得所有进程都可以顺利完成的状态。

判断系统是否处于安全状态的方法如下:(1)计算每个进程的最大需求。

(2)计算系统可利用的资源。

(3)从最大需求中减去已分配的资源,得到剩余需求。

(4)判断剩余需求是否小于等于系统可利用的资源。

操作系统银行家算法实验报告

操作系统银行家算法实验报告

操作系统银行家算法实验报告操作系统银行家算法实验报告引言:操作系统是计算机科学中的一个重要领域,它负责管理计算机的硬件和软件资源,以提供良好的用户体验。

在操作系统中,银行家算法是一种重要的资源分配和调度算法,它可以确保系统中的进程安全地访问资源,避免死锁的发生。

本实验旨在通过实践运用银行家算法,深入理解其原理和应用。

实验目的:1. 理解银行家算法的基本原理;2. 掌握银行家算法的实现方法;3. 分析银行家算法在资源管理中的应用。

实验过程:1. 实验环境的搭建在本次实验中,我们使用了一台运行Windows操作系统的计算机,并安装了Java开发环境。

同时,我们使用了一个模拟的资源管理系统,以便更好地理解和实践银行家算法。

2. 银行家算法的原理银行家算法是通过对系统中的资源进行合理分配,以避免死锁的发生。

它基于以下几个假设:- 每个进程对资源的最大需求量是已知的;- 系统中的资源数量是有限的;- 进程在请求资源时必须先声明其最大需求量;- 进程在释放资源后,不能再重新请求。

3. 银行家算法的实现银行家算法的实现主要包括以下几个步骤:- 初始化:获取系统中的资源总量和每个进程的最大需求量;- 安全性检查:通过模拟分配资源并检查系统是否处于安全状态,以确定是否可以满足进程的资源请求;- 资源分配:根据安全性检查的结果,决定是否分配资源给进程。

4. 银行家算法的应用银行家算法在实际应用中具有广泛的用途,尤其是在多任务操作系统中。

它可以用于资源的分配和调度,以确保系统中的进程能够安全地访问资源,避免死锁的发生。

结论:通过本次实验,我们深入了解了银行家算法的原理和应用。

银行家算法作为一种重要的资源管理和调度算法,可以有效地避免死锁的发生,提高系统的可靠性和稳定性。

在今后的学习和工作中,我们将继续深入研究操作系统相关的算法和原理,以提升自己在该领域的专业能力。

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

xx大学操作系统实验报告姓名:学号:班级:实验日期:实验名称:预防进程死锁的银行家算法实验三预防进程死锁的银行家算法1.实验目的:通过编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用适当的算法,有效地防止和避免死锁地发生。

理解银行家算法的运行原理,进一步掌握预防进程死锁的策略及对系统性能的评价方法。

:2. 需求分析(1) 输入的形式和输入值的范围;输入:首先输入系统可供资源种类的数量n 范围:0<n<=100资源1的名称:资源的数量:资源2的名称:资源的数量:。

输入作业的数量m 范围:0<m<=100输入个进程的最大需求量<m*n矩阵>[Max]:输入个进程已经申请的资源量<m*n矩阵>[Allocation]:(2) 输出的形式系统目前可用的资源[Avaliable]:(显示系统是否安全)分配序列:(3)程序所能达到的功能通过手动输入资源种类数量和各进程的最大需求量、已经申请的资源量,运用银行家算法检测系统是否安全,若安全则给出安全序列,并且当用户继续输入某进程的资源请求时,能够继续判断系统的安全性。

(4) 测试数据,包括正确的输入及其输出结果和含有错误的输入及其输出结果。

正确输入输入参数(已申请资源数)错误3、概要设计所有抽象数据类型的定义:int Max[100][100]; //各进程所需各类资源的最大需求int Avaliable[100]; //系统可用资源char name[100] };//资源的名称int Allocation[100][100]; //系统已分配资源int Need[100][100] }; //还需要资源int Request[100]; //请求资源向量int temp[100]; //存放安全序列int Work[100];//存放系统可提供资源int M=100; //作业的最大数为100int N=100; //资源的最大数为100主程序的流程:* 变量初始化;* 接收用户输入n,m,Max ij,Allocation ij;* 按照银行家算法判断当前状态安全与否,安全给出安全序列,不安全给出提示;* 如果安全,提示用户输入下一时刻进程P k的资源请求Request(R1, … ,R m);* 如果不安全或者无新请求则退出。

各程序模块之间的层次(调用)关系使用Main函数对全局变量进行初始化,然后调用showdata函数对各资源和进程进行整合显示,最后调用safe函数即银行家算法判定系统是否安全。

若安全,并想继续对某进程进行资源请求,则调用request函数进行操作,其中request函数又调用changedata函数、showdata函数和safe函数进行请求后的数据修改、显示以及对系统安全性的判定。

4、详细设计实现程序模块的具体算法。

int safe()//安全性算法{int i,k=0,m,apply,Finish[100]={0};int j;int flag=0;Work[0]=Avaliable[0];Work[1]=Avaliable[1];Work[2]=Avaliable[2];for(i=0;i<M;i++){apply=0;for(j=0;j<N;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){apply++;if(apply==N){for(m=0;m<N;m++)Work[m]=Work[m]+Allocation[i][m];//变分配数Finish[i]=True;temp[k]=i;i=-1;k++;flag++;}}}}for(i=0;i<M;i++){if(Finish[i]==False){cout<<"系统不安全"<<endl;//不成功系统不安全return -1;}}cout<<"系统是安全的!"<<endl;//如果安全,输出成功cout<<"安全序列:";for(i=0;i<M;i++){//输出运行进程数组cout<<temp[i];if(i<M-1) cout<<"->";}cout<<endl;return 0;}5、调试分析(1)调试过程中遇到的问题以及解决方法,设计与实现的回顾讨论和分析起初,对于银行家算法的运算步骤有一定的偏差,导致在将算法编码时造成了一些错误,结果无法得到正确答案,之后通过仔细查阅银行家算法的步骤,问题得以及时解决。

(2)算法的性能分析用户对可供资源和各进程所需要的最大资源量和已分配资源量进行赋值,可得到系统的安全性判定,以及安全时的安全序列以及对资源进行请求后的系统安全性判定。

(3)经验体会通过对银行家算法的编码,让我对银行家算法的原理有了更为深刻的理解,同时也让我意识到只有通过亲自动手实践,才能加深对算法思想的理解与记忆。

6、用户使用说明程序的使用说明,列出每一步的操作步骤。

7、测试结果列出测试结果,包括输入和输出。

之后对进程一进行资源请求:8、附录带注释的源程序,注释应清楚具体#include<>#include<>#include<>#define False 0#define True 1int Max[100][100]={0};//各进程所需各类资源的最大需求int Avaliable[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};//存放系统可提供资源int M=100;//作业的最大数为100int N=100;//资源的最大数为100void showdata()//显示资源矩阵{int i,j;cout<<"系统目前可用的资源[Avaliable]:"<<endl;for(i=0;i<N;i++)cout<<name[i]<<" ";cout<<endl;for (j=0;j<N;j++)cout<<Avaliable[j]<<" ";//输出分配资源cout<<endl;cout<<" Max Allocation Need"<<endl;cout<<"进程名";for(j=0;j<3;j++){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;}}int changdata(int i)//进行资源分配{int j;for (j=0;j<M;j++) {Avaliable[j]=Avaliable[j]-Request[j];Allocation[i][j]=Allocation[i][j]+Request[j];Need[i][j]=Need[i][j]-Request[j];}return 1;}int safe()//安全性算法{int i,k=0,m,apply,Finish[100]={0};int j;int flag=0;Work[0]=Avaliable[0];Work[1]=Avaliable[1];Work[2]=Avaliable[2];for(i=0;i<M;i++){apply=0;for(j=0;j<N;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){apply++;if(apply==N){for(m=0;m<N;m++)Work[m]=Work[m]+Allocation[i][m];//变分配数Finish[i]=True;temp[k]=i;i=-1;k++;flag++;}}}}for(i=0;i<M;i++){if(Finish[i]==False){cout<<"系统不安全"<<endl;//不成功系统不安全return -1;}}cout<<"系统是安全的!"<<endl;//如果安全,输出成功cout<<"安全序列:";for(i=0;i<M;i++){//输出运行进程数组cout<<temp[i];if(i<M-1) cout<<"->";}cout<<endl;return 0;}void request()//利用银行家算法对申请资源对进行判定{char ch;int i=0,j=0;ch='y';cout<<"请输入要求分配的资源进程号(0-"<<M-1<<"):";cin>>i;//输入须申请的资源号cout<<"请输入进程"<<i<<" 申请的资源:"<<endl;for(j=0;j<N;j++){cout<<name[j]<<":";cin>>Request[j];//输入需要申请的资源}for (j=0;j<N;j++){if(Request[j]>Need[i][j])//判断申请是否大于需求,若大于则出错{cout<<"进程"<<i<<"申请的资源大于它需要的资源";cout<<" 分配不合理,不予分配!"<<endl;ch='n';break;}else {if(Request[j]>Avaliable[j])//判断申请是否大于当前资源,若大于则{ //出错cout<<"进程"<<i<<"申请的资源大于系统现在可利用的资源";cout<<" 分配出错,不予分配!"<<endl;ch='n';break;}}}if(ch=='y') {changdata(i);//根据进程需求量变换资源showdata();//根据进程需求量显示变换后的资源safe();//根据进程需求量进行银行家算法判断}}int main()//主函数{int i,j,number,m,n,flag,choice;char ming;cout<<"*****************单处理机系统进程调度实现*****************"<<endl;cout<<"请首先输入系统可供资源种类的数量:";cin>>n;N=n;for(i=0;i<n;i++){cout<<"资源"<<i+1<<"的名称:";cin>>ming;name[i]=ming;cout<<"资源的数量:";cin>>number;Avaliable[i]=number;}cout<<endl;cout<<"请输入作业的数量:";cin>>m;M=m;cout<<"请输入各进程的最大需求量("<<m<<"*"<<n<<"矩阵)[Max]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>Max[i][j];do{flag=0;cout<<"请输入各进程已经申请的资源量("<<m<<"*"<<n<<"矩阵)[Allocation]:"<<endl;for(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);showdata();//显示各种资源safe();//用银行家算法判定系统是否安全while(choice){cout<<"***********************************"<<endl;cout<<" 0:离开"<<endl;cout<<" 1:资源请求"<<endl;cout<<"请选择功能号:";cin>>choice;switch(choice){case 1: request();break;case 0: choice=0;break;default: cout<<"请正确选择功能号(0-1)!"<<endl;break;}}return 1;}。

相关文档
最新文档