银行家算法实验报告(20201009162955)

合集下载

银行家算法实验报告总结

银行家算法实验报告总结

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告银行家算法是为了实现避免出现死锁的状态而采取的一种算法,本实验则是用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)初始化时让系统拥有一定的资源;(3)用键盘输入的方式申请资源;(4)如果预分配后,系统处于安全状态,则修改系统的资源分配情况;(5)如果预分配后,系统处于不安全状态,则提示不能满足请求,设计的主要内容是模拟实现动态资源分配。

同时编写和调试一个系统动态资源的简单模拟程序,观察死锁产生的条件,并使用适当的算法,有效的防止和避免死锁的发生。

银行家算法.顾名思义是来源于银行的借贷业务,一定数量的本金要应多个客户的借贷周转,为了防止银行加资金无法周转而倒闭,对每一笔贷款,必须考察其是否能限期归还。

在操作系统中研究资源分配策略时也有类似问题,系统中有限的资源要供多个进程使用,必须保证得到的资源的进程能在有限的时间内归还资源,以供其他进程使用资源。

如果资源分配不得到就会发生进程循环等待资源,则进程都无法继续执行下去的死锁现象。

把一个进程需要和已占有资源的情况记录在进程控制中,假定进程控制块PCB其中“状态”有就绪态、等待态和完成态。

当进程在处于等待态时,表示系统不能满足该进程当前的资源申请。

“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。

显然,,每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以避免死锁.二、算法描述及数据结构模型1.银行家算法:设进程i提出请求Request[n],则银行家算法按如下规则进行判断。

(1)如果Request[n]>Need[i,n],则报错返回。

(2)如果Request[n]>Available,则进程i进入等待资源状态,返回。

(3)假设进程i的申请已获批准,于是修改系统状态:Available=Available-RequestAllocation=Allocation+RequestNeed=Need-Request(4)系统执行安全性检查,如安全,则分配成立;否则试探险性分配作废,系统恢复原状,进程等待。

银行家算法实验报告

银行家算法实验报告

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

三、问题分析与设计: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)。

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告关键字:银行家算法、安全状态、不安全状态、向量矩阵、进程、死锁、资源、就绪状态、执行状态、阻塞状态;一实验名称进程同步互斥问题二实验目的2.1切实加深对进程死锁的认识;2.2正确理解系统的安全状态与不安全状态;2.3更进一步地理解和掌握银行家算法;三实验要求3.1将本实验分成两个阶段,第一阶段实现系统安全性检测算法;第二阶段实现银行家算法;3.2要求用户能自主地输入不同的向量矩阵;3.3你的程序能正确输出不同的运算结果;3.4你的程序应具备良好的容错能力;3.5力求用户界面的简洁美观;四实验原理4.1 进程及进程死锁;4.1.1 进程:是操作系统中最基本、最重要的概念,但直到目前还没有一个统一的定义,下面通过能反映进程实质的几点描述来认识进程:①进程是程序的一次执行;②进程是可以和别的计算并发执行的计算;③进程是程序在一个数据集合上运行的过程,是系统进行资源分配和调度的一个独立单位;④进程是一个具有一定功能的程序关于某个数据集合的一次运行活动。

进程具有几个基本的特征:动态性、并发性、独立性、异步性;每个进程通常由程序段、数据段和进程控制块三部分组成,其中进程控制块能唯一标识一个进程。

进程执行时间的间断性,决定了进程可能具有多种状态。

事实上,运行中的进程至少具有以下三种基本状态:就绪状态:进程已获得除处理机以外的所有资源,一旦分到了处理机就可以立即执行,这时进程所处的状态为就绪状态;执行状态:又称运行状态。

当一个进程获得必要的资源,并占有处理机,即在处理机上运行,此时进程所处的状态为执行状态;阻塞状态:又称等待状态,正在执行的进程,由于发生了某事件而暂时无法执行下去(如等待输入/输出完成),此时进程所处的状态称为阻塞状态。

进程并非固定处于某一状态,它随着自身的推进和外界条件的变化而发生变化。

4.1.2 进程死锁进程死锁是因多个进程因竞争资源而造成的一种僵局,若无外力作用,这些进程都无法向前推进。

银行家算法实验报告绪论

银行家算法实验报告绪论

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

银行家算法实验报告

银行家算法实验报告

银行家算法实验报告引言:在计算机科学领域,由于资源的有限性,进程资源分配问题一直备受关注。

而银行家算法被广泛应用于操作系统中,用于确保资源的安全分配。

本文旨在介绍银行家算法的原理和应用,并通过实验报告来验证该算法的有效性和可行性。

1. 银行家算法简介银行家算法是由美国学者Dijkstra提出的一种资源分配和避免死锁的算法。

其基本思想是通过银行家的原则来避免系统陷入死锁状态,保证资源分配的安全性和可行性。

银行家算法适用于具有多个进程和多个资源的并发系统中。

2. 银行家算法原理银行家算法基于两个重要的概念:安全性和可分配性。

安全性表示在系统当前状态下,是否存在一种资源分配序列可以使系统避免死锁状态。

可分配性表示系统是否能够满足进程对资源的请求。

银行家算法的实现需要以下几个关键步骤:(1) 初始化:对每个进程设置最大需求量、已分配资源量和需求资源量。

(2) 效验:判断系统当前状态下资源是否满足所有进程的需求,即判断系统是否处于安全状态。

(3) 分配:若系统处于安全状态,则根据某种资源分配策略,为进程分配资源。

(4) 请求:进程请求资源。

(5) 回收:进程释放资源。

3. 银行家算法的实验验证为了验证银行家算法的有效性和可行性,我们设置了一个简单的实验环境,模拟一个有限的资源系统,包含3个进程和3种不同类型的资源。

实验过程如下:(1) 初始化:对每个进程设置最大需求量、已分配资源量和需求资源量。

设置3个进程的最大需求量分别为{5, 4, 3},已分配资源量分别为{1, 2, 2},需求资源量分别为{3, 2, 0}。

(2) 效验:判断系统当前状态下资源是否满足所有进程的需求。

经过实验验证,我们发现系统当前状态下资源无法满足进程2的资源需求。

为了保证系统的安全性和避免死锁,根据银行家算法原理,我们将不满足资源需求的进程2暂停,并回滚到初始状态。

重新调整资源分配后,系统进入了安全状态。

(3) 分配:为进程1和进程3分配资源。

银行家算法课程设计实验报告

银行家算法课程设计实验报告

银行家算法课程设计实验报告摘要:本文主要介绍了一种新的实验方法——银行家算法课程设计实验,针对算法教学的实验设计,特别是在银行家算法这一领域,运用Visual C++ 语言,给出了一种实验实现及其相应的实验报告。

实验的通过对 Visual C++ 的开发环境及语法的掌握,实验证明了银行家算法的可行性和实际应用的安全性。

关键词:银行家算法;Visual C++;实验设计;实验报告1. 绪论随着网络技术的不断发展和深化,如今网络系统的仿真实验,尤其是银行家算法的仿真实验的需求量日益增大,该实验将把网络系统设计中的概念、原理以及运用的方法用于系统的实际应用,更直观地表达出网络实验中的概念。

本实验希望通过对 Visual C++语言的开发环境及语法的掌握,实现银行家算法在计算机系统中的运用,实现这种算法的可行性和实际应用的安全性,从而使网络系统仿真实验更加简单有效的实现。

2. 实验目的(1)熟悉 Visual C++ 语言的开发环境及语法;(2)了解银行家算法基本原理及其实现;(3)验证银行家算法的可行性及实际应用的安全性;(4)为网络系统仿真实验提供一种新的实验方法。

3. 实验内容(1)Visual C++编程环境的熟悉;(2)实现银行家算法的仿真实验;(3)验证银行家算法的可行性和实际应用的安全性;(4)实验报告的编写。

4. 实验环境实验环境主要包括实验平台、操作系统、语言编程工具和文本编辑器。

实验平台:实验所使用的计算机硬件平台为:Intel 酷睿i5-8400 处理器、 DDR4 8G 内存及 GTX 1050TI 4G 显卡;操作系统:实验所使用的操作系统为 Windows 10 家庭版;语言编程工具:实验所使用的语言编程工具为 Visual Studio 2017;文本编辑器:实验所使用的文本编辑器为 Notepad。

5. 实验过程实验过程主要包括 Visual C++ 编程环境的熟悉、银行家算法的仿真实现及实验报告的编写。

实验二银行家算法实验报告

实验二银行家算法实验报告

实验二银行家算法实验报告一、实验目的通过本次实验,主要学习了解了银行家算法的原理和实现方式,掌握银行家算法的应用场景,了解了安全序列的概念和判断方法,并通过代码实现加深对银行家算法的理解和掌握。

二、实验过程1、阅读银行家算法的相关理论知识。

2、编写银行家算法的代码实现。

3、根据实验要求,设置不同的初始资源分配和不同的进程请求资源情况,分别计算是否存在安全序列。

三、实验结果与分析1、首先按照实验要求设置一个初始的资源分配情况:可用的资源数目:4 4 4进程数目:4各进程对三种资源的最初需要数目:Max:7 5 33 2 29 0 22 2 2已分配资源数目:Allocation:0 1 02 0 03 0 22 1 1剩余资源数目:Need: 7 4 31 2 26 0 00 1 1根据上述数据,计算出该初试分配情况下的安全序列为:1 -> 3 -> 4 -> 2。

2、然后设置一个进程请求资源的情况:进程 1 请求资源 [3,3,0],进程 2 请求资源 [1,0,1],进程 3 请求资源 [2,2,0],进程 4 请求资源 [0,0,2]。

根据银行家算法,先进行安全性检测,发现该系统不存在安全序列,因此不满足银行家算法的要求,请求不被满足。

3、接着修改初始的资源分配情况和请求的资源情况,进行比较:通过以上的实验操作,得出结论:只有当请求的资源不会导致系统不再安全时,才会满足请求。

银行家算法基于这个假设进行运算,它管理着一个可以分配的表格,该表格显示系统的各种资源已经分配和未分配的情况,并确定哪些进程可以分配资源,哪些不可以。

四、实验总结本次实验通过对银行家算法的概念、原理和应用场景的了解,对该算法有了更深的认识和理解,并通过代码实现和实验操作,进一步巩固和掌握了该算法的应用方法。

在实验过程中,也有一些需要注意的问题:如需要按照一定的顺序输入原数据,正确地计算资源分配和剩余情况;核实每个请求的资源数目是否足够,才进行安全性检测;注意计算过程中数值的准确性和解题思路的正确性等。

c语言银行家算法实验报告

c语言银行家算法实验报告

c语言银行家算法实验报告C语言银行家算法实验报告引言:计算机科学领域中,操作系统的资源管理是一个十分重要的课题。

在多任务处理系统中,多个进程同时竞争有限的资源,如何合理地分配和调度资源,以保证系统的稳定性和效率,是一个关键问题。

银行家算法(Banker's Algorithm)是一种经典的资源分配算法,它通过分析系统的资源状态和进程的资源需求,来判断是否能够安全地分配资源,从而避免产生死锁。

一、实验目的本次实验旨在通过C语言编程实现银行家算法,加深对资源管理和死锁问题的理解,并通过实际案例验证银行家算法的有效性。

二、实验环境本次实验使用C语言进行编程,并在Linux操作系统下进行测试。

三、实验过程1. 设计数据结构在开始编写代码之前,我们需要先设计适合的数据结构来表示系统资源和进程的状态。

在银行家算法中,我们需要记录系统中的可用资源数量、各个进程的最大需求资源数量、已分配资源数量和需要资源数量等信息。

通过定义合适的数据结构,我们可以方便地进行资源的分配和回收。

2. 实现银行家算法根据银行家算法的原理,我们可以将其分为两个步骤:安全性检查和资源分配。

在安全性检查中,我们需要判断当前系统状态下是否存在安全序列,即是否能够满足所有进程的资源需求,避免死锁的发生。

在资源分配中,我们需要根据当前系统状态和进程的资源需求,动态地分配和回收资源。

3. 编写测试用例为了验证银行家算法的正确性和有效性,我们需要编写一些测试用例。

测试用例应该包括各种不同的进程资源需求和系统资源状态,以覆盖不同情况下的资源分配和回收。

4. 运行测试用例在编写完测试用例后,我们可以运行程序,观察输出结果。

通过比较实际输出与预期结果,我们可以判断银行家算法的正确性和有效性。

四、实验结果与分析通过运行多个测试用例,我们可以得出以下结论:1. 银行家算法能够有效地避免死锁的发生。

在安全性检查过程中,如果存在安全序列,那么系统可以继续分配资源,否则需要阻塞等待。

银行家算法试验报告

银行家算法试验报告

一、实验题目:银行家算法的实现二、设计内容设计一个n 个并发进程共享m 个系统资源的系统。

进程可动态申请资源和释放资源,系统按各进程的申请动态的分配资源。

要求采用银行家算法实现。

三、开发环境windows环境,java1.5平台。

四、分析设计<一>实验原理♦银行家算法是从当前状态出发,逐个按安全序列检查各客户中谁能完成其工作,然后假定其完成工作且归还全部贷款,再进而检查下一个能完成工作的客户。

如果所有客户都能完成工作,则找到一个安全序列,银行家才是安全的。

♦与预防死锁的几种方法相比较,限制条件少,资源利用程度提高了。

♦缺点:该算法要求客户数保持固定不变,这在多道程序系统中是难以做到的;该算法保证所有客户在有限的时间内得到满足,但实时客户要求快速响应,所以要考虑这个因素;由于要寻找一个安全序列,实际上增加了系统的开销.Banker algorithm 最重要的一点是:保证操作系统的安全状态!这也是操作系统判断是否分配给一个进程资源的标准!那什么是安全状态?举个小例子,进程P 需要申请8 个资源(假设都是一样的),已经申请了 5 个资源,还差3 个资源。

若这个时候操作系统还剩下 2 个资源。

很显然,这个时候操作系统无论如何都不能再分配资源给进程P 了,因为即使全部给了他也不够,还很可能会造成死锁。

若这个时候操作系统还有 3 个资源,无论P 这一次申请几个资源,操作系统都可以满足他,因为操作系统可以保证P 不死锁,只要他不把剩余的资源分配给别人,进程P 就一定能顺利完成任务。

为什么银行家算法是可行的呢?这里需要严格的证明一下。

不管任何时候,操作系统分配资源的时候都可以保证当前接受资源的进程不会陷入死锁,因为操作系统总是可以满足该进程需要的资源的。

假设有n 个进程{p1, p2, p3, …pn} ,最后一个分配到资源的是pi ,pi 还需要mi 个资源,假设此时操作系统还有m 个资源剩余。

那么很显然m>=mi !而且如果之后操作系统又把资源分配给其他进程了,假设是pj ,pj 还需要mj 个资源,同理可知m>=mj !也就是说在所有的进程中,还需要的资源数总是有小于m 的!这样就可以保证资源数永远不会为0 ,即使可能暂时性为0 。

实验三银行家算法实验报告

实验三银行家算法实验报告

实验三银行家算法实验报告一、实验目的银行家算法是一种用于避免死锁的算法,本次实验旨在通过编程实现银行家算法,并通过模拟银行家算法的运行过程来加深对该算法的理解。

二、实验过程及结果1. 系统设计为了模拟银行家算法的运行过程,需要设计一个包含多个进程和资源的系统。

每个进程都有一定的最大需求资源数和已分配资源数。

系统中还有一定数量的可用资源,进程可以请求资源和释放资源。

2. 算法实现在程序中实现银行家算法需要以下几个关键的函数:(1)银行家算法的主函数:实现进程的请求资源和释放资源操作,并在此过程中判断是否产生死锁;(2)安全检查函数:用于判断系统状态是否安全,即是否存在一个安全序列,如果存在则表示系统处于安全状态,否则表示系统处于不安全状态;(3)资源请求函数:用于进程请求资源的操作,根据银行家算法的要求进行判断;(4)资源释放函数:用于进程释放资源的操作。

3. 算法运行通过对编写的程序进行多次运行测试,模拟不同进程对资源的请求和释放,观察系统是否能够始终处于安全状态。

在每次运行中,记录并输出系统的安全序列和进程的状态等信息。

4. 实验结果分析通过实验运行结果的分析,可以得出以下结论:(1)银行家算法能够有效地避免死锁的发生;(2)系统中资源的分配和释放过程需要合理,否则可能导致系统陷入死锁;(3)资源的分配策略对系统的安全状态有重要影响。

三、实验总结通过本次实验,深入了解了银行家算法的原理和实现过程,并通过编程实践加深了对该算法的理解。

银行家算法是一种重要的死锁避免算法,能够保证系统处于安全状态下运行,并且能够合理地分配系统资源,避免系统陷入死锁。

四、参考文献[1] 《操作系统概念》,Abraham Silberschatz,Peter B. Galvin,Greg Gagne,电子工业出版社,2014年五、附录(示例代码省略)以上是本次实验的实验报告,通过实验我们深入了解了银行家算法,了解了它在操作系统中的应用和重要性。

银行家算法实验报告

银行家算法实验报告

《银行家算法的模拟实现》实验报告题目:银行家算法的模拟实现专业:软件工程班级:B184学号:20180614423姓名:吴文骏日期:2020年5月23日一、实验目的1、理解银行家算法。

2、掌握进程安全性检查的方法与资源分配的方法二、实验内容与基本要求编制模拟银行家算法的程序,并给出一个例子验证所编写的程序的正确性。

三、实验报告内容银行家算法和安全性检查算法原理:我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。

为保证资金的安全,银行家规定:(1)当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;(2)顾客可以分期贷款,但贷款的总数不能超过最大需求量;(3)当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;(4)当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金。

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

当进程在执行中继续申请资源时,先测试该进程本次申请的资源数是否超过了该资源所剩余的总量。

若超过则拒绝分配资源,若能满足则按当前的申请量分配资源,否则也要推迟分配。

(一)银行家算法(bank()函数):进程i发出请求资源申请,(1)如果Request [j]<=need[i,j],转向步骤(2),否则认为出错,因为他所需要的资源数已经超过它所宣布的最大值。

(2)如果:Request i[j]<=available[i,j],转向步骤(3),否则表示尚无足够资源,进程i需等待。

(3)若以上两个条件都满足,则系统试探着将资源分配给申请的进程,并修改下面数据结构中的数值:Available[i,j]= Available[i,j]- Request [j];Allocation[i][j]= Allocation[i][j]+ Request [j];need[i][j]= need[i][j]- Request [j];(4)试分配后,执行安全性检查,调用check()函数检查此次资源分配后系统是否处于安全状态。

实验三 银行家算法 实验报告

实验三 银行家算法 实验报告
Available[j]= Available[j]- Request[i,j];
Allocation[i,j]= Allocation[i,j]+ Request[i,j];
Need[i,j]= Need[i,j]- Request[i,j];
(4)系统执行安全性算法,即转向步骤(5)
(5)初始化Finish[i]=false;当有足够资源分配给进程时,再令Finish[i]=true。
(6)从进程集合中找到一个能满足下述条件的进程:①Finish[i]=false;②Need[i,j] <= Work[j];若找到,执行步骤(7),否则,执行步骤(8)。
(7)当进程Pi获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,且执行:
Work[j]= Work[i]+ Allocation[i,j];
Finish[i]=true;
go to step(5);
(8)如果所有进程的Finish[i]=true都满足,则表示系统处于安全状态;即系统可以将资源分配给该进程。否则,该进程请求分配资源失败。
3、流程图
五、实验结果和分析(实验结果截图)
六、成绩评定
三、主要器材设备和原料
1.PC微机。
2.Windows操作系统。
3.C语言开发集成环境。
四、实验过程和步骤(比如流程图)
1.本实验具体要求
(1)设计进程对各类资源最大申请表示及初值确定。
(2)设定系统提供资源初始状况。
(3)设定每次某个进程对各类资源的申请表示。
(4)编制程序,依据银行家算法,决定其申请是否得到满足。
二、实验原理(主要写算法思想)资源且是否是不大于可利用的资源。若请求的资源不大于需要资源且不大于可利用的资源,则修改该进程的相关资源并对试分配后的状态调用安全性检查算法进行安全性检查。若安全,则分配资源申请资源成功。否则,不分配,恢复原来状态,拒绝申请。

银行家算法实验报告

银行家算法实验报告

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);* 如果不安全或者无新请求则退出。

银行家算法_实验报告

银行家算法_实验报告

课程设计报告课程设计名称共享资源分配与银行家算法系(部)专业班级姓名学号指导教师年月日目录一、课程设计目的和意义 (3)二、方案设计及开发过程 (3)1.课题设计背景 (3)2.算法描述 (3)3.数据结构 (4)4.主要函数说明 (4)5.算法流程图 (5)三、调试记录与分析四、运行结果及说明 (6)1.执行结果 (6)2.结果分析 (7)五、课程设计总结 (8)一、程设计目的和意义计算机科学与技术专业学生学习完《计算机操作系统》课程后,进行的一次全面的综合训练,其目的在于加深催操作系统基础理论和基本知识的理解,加强学生的动手能力. 银行家算法是避免死锁的一种重要方法。

通过编写一个模拟动态资源分配的银行家算法程序,进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念,并掌握避免死锁的具体实施方法二、方案设计及开发过程1.课题设计背景银行家算法又称“资源分配拒绝”法,其基本思想是,系统中的所有进程放入进程集合,在安全状态下系统受到进程的请求后试探性的把资源分配给他,现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较,找出剩余资源能满足最大需求量的进程,从而保证进程运行完成后还回全部资源。

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

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

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

请进程等待2.算法描述1)如果Request[i] 是进程Pi的请求向量,如果Request[i,j]=K,表示进程Pi 需要K个Rj类型的资源。

当Pi发出资源请求后,系统按下述步骤进行检查:如果Requesti[j]<= Need[i,j],便转向步骤2;否则认为出错,因为它所需要的资源数已超过它所宣布的最大值。

2)如果Requesti[j]<=Available[j],便转向步骤3,否则,表示尚无足够资源,进程Pi须等待。

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

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

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

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

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

正确输入输入参数(已申请资源数)错误3、概要设计所有抽象数据类型的定义:int Max[100][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(R,…,R);* 如果不安全或者无新请求则退出。

各程序模块之间的层次(调用)关系使用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附录带注释的源程序,注释应清楚具体#i nclude<iostream.h> #i nclude<stri ng.h> #i nclude<stdio.h>#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<<" 矩阵)[Allocati on ]:"<<e ndl;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;}。

相关文档
最新文档