银行家算法报告和代码
银行家算法实验报告

银行家算法实验报告银行家算法是为了实现避免出现死锁的状态而采取的一种算法,本实验则是用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时才能表示安全算法成功。
操作系统实验报告--C语言实现银行家算法

实验报告程序源代码:#include <stdio.h>#include <stdlib.h>#include <conio.h># define m 50int no1; //进程数int no2; //资源数int r;int allocation[m][m],need[m][m],available[m],max[m][m];char name1[m],name2[m]; //定义全局变量void main(){void check();void print();int i,j,p=0,q=0;char c;int request[m],allocation1[m][m],need1[m][m],available1[m];printf("**********************************************\n");printf("* 银行家算法的设计与实现 *\n");printf("**********************************************\n");printf("请输入进程总数:\n");scanf("%d",&no1);printf("请输入资源种类数:\n");scanf("%d",&no2);printf("请输入Max矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&max[i][j]); //输入已知进程最大资源需求量printf("请输入Allocation矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&allocation[i][j]); //输入已知的进程已分配的资源数for(i=0;i<no1;i++)for(j=0;j<no2;j++)need[i][j]=max[i][j]-allocation[i][j]; //根据输入的两个数组计算出need矩阵的值printf("请输入Available矩阵\n");for(i=0;i<no2;i++)scanf("%d",&available[i]); //输入已知的可用资源数print(); //输出已知条件check(); //检测T0时刻已知条件的安全状态if(r==1) //如果安全则执行以下代码{do{q=0;p=0;printf("\n请输入请求资源的进程号(0~4):\n");for(j=0;j<=10;j++){scanf("%d",&i);if(i>=no1){printf("输入错误,请重新输入:\n");continue;}else break;}printf("\n请输入该进程所请求的资源数request[j]:\n");for(j=0;j<no2;j++)scanf("%d",&request[j]);for(j=0;j<no2;j++)if(request[j]>need[i][j]) p=1;//判断请求是否超过该进程所需要的资源数if(p)printf("请求资源超过该进程资源需求量,请求失败!\n");else{for(j=0;j<no2;j++)if(request[j]>available[j]) q=1;//判断请求是否超过可用资源数if(q)printf("没有做够的资源分配,请求失败!\n");else //请求满足条件{for(j=0;j<no2;j++){available1[j]=available[j];allocation1[i][j]=allocation[i][j];need1[i][j]=need[i][j];//保存原已分配的资源数,仍需要的资源数和可用的资源数available[j]=available[j]-request[j];allocation[i][j]+=request[j];need[i][j]=need[i][j]-request[j];//系统尝试把资源分配给请求的进程}print();check(); //检测分配后的安全性if(r==0) //如果分配后系统不安全{for(j=0;j<no2;j++){available[j]=available1[j];allocation[i][j]=allocation1[i][j];need[i][j]=need1[i][j];//还原已分配的资源数,仍需要的资源数和可用的资源数}printf("返回分配前资源数\n");print();}}}printf("\n你还要继续分配吗?Y or N ?\n");//判断是否继续进行资源分配c=getche();}while(c=='y'||c=='Y');}}void check() //安全算法函数{int k,f,v=0,i,j;int work[m],a[m];bool finish[m];r=1;for(i=0;i<no1;i++)finish[i]=false; // 初始化进程均没得到足够资源数并完成for(i=0;i<no2;i++)work[i]=available[i];//work[i]表示可提供进程继续运行的各类资源数k=no1;do{for(i=0;i<no1;i++){if(finish[i]==false){f=1;for(j=0;j<no2;j++)if(need[i][j]>work[j])f=0;if(f==1) //找到还没有完成且需求数小于可提供进程继续运行的资源数的进程{finish[i]=true;a[v++]=i; //记录安全序列号for(j=0;j<no2;j++)work[j]+=allocation[i][j]; //释放该进程已分配的资源}}}k--; //每完成一个进程分配,未完成的进程数就减1 }while(k>0);f=1;for(i=0;i<no1;i++) //判断是否所有的进程都完成{if(finish[i]==false){f=0;break;}}if(f==0) //若有进程没完成,则为不安全状态{printf("系统处在不安全状态!");r=0;}else{printf("\n系统当前为安全状态,安全序列为:\n");for(i=0;i<no1;i++)printf("p%d ",a[i]); //输出安全序列}}void print() //输出函数{int i,j;printf("\n");printf("*************此时刻资源分配情况*********************\n");printf("进程名/号 | Max | Allocation | Need |\n"); for (i = 0; i < no1; i++){printf(" p%d/%d ",i,i);for (j = 0; j < no2; j++){printf("%d ",max[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",allocation[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",need[i][j]);}printf("\n");}printf("\n");printf("各类资源可利用的资源数为:");for (j = 0; j < no2; j++){printf(" %d",available[j]);}printf("\n");}程序运行调试结果:1、程序初始化2、检测系统资源分配是否安全结果。
银行家算法流程图+C++源代码+实验报告-课程设计

银行家算法流程图+C++源代码+实验报告-课程设计银行家算法流程图+C++源代码+实验报告摘要:银行家算法是避免死锁的一种重要方法。
操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。
当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量,若能满足则按当前的申请量分配资源,否则也要推迟分配。
银行家算法确实能保证系统时时刻刻都处于安全状态,但它要不断检测每个进程对各类资源的占用和申请情况,需花费较多的时间。
现在的大部分系统都没有采用这个算法,也没有任何关于死锁的检查。
关键字:银行家算法,系统安全,死琐 1,银行家算法原理银行家算法是从当前状态出发,逐个按安全序列检查各客户中谁能完成其工作,然后假定其完成工作且归还全部贷款,再进而检查下一个能完成工作的客户。
如果所有客户都能完成工作,则找到一个安全序列,银行家才是安全的。
缺点:该算法要求客户数保持固定不变,这在多道程序系统中是难以做到的;该算法保证所有客户在有限的时间内得到满足,但实时客户要求快速响应,所以要考虑这个因素;由于要寻找一个安全序列,实际上增加了系统的开销.Banker algorithm 最重要的一点是:保证操作系统的安全状态!这也是操作系统判断是否分配给一个进程资源的标准!那什么是安全状态?举个小例子,进程P 需要申请 8 个资源(假设都是一样的),已经申请了 5 个资源,还差 3 个资源。
若这个时候操作系统还剩下 2 个资源。
很显然,这个时候操作系统无论如何都不能再分配资源给进程 P 了,因为即使全部给了他也不够,还很可能会造成死锁。
若这个时候操作系统还有 3 个资源,无论 P 这一次申请几个资源,操作系统都可以满足他,因为操作系统可以保证 P 不死锁,只要他不把剩余的资源分配给别人,进程 P 就一定能顺利完成任务。
java银行家算法代码实现

java银行家算法代码实现=================一、算法简介------银行家算法是一种用于避免系统发生死锁的算法,它通过分析系统资源分配情况,判断系统是否处于安全状态,从而避免死锁的发生。
Java银行家算法是一种基于Java语言的实现,它通过模拟系统资源分配情况,判断系统是否处于安全状态。
二、算法实现------以下是一个简单的Java银行家算法代码实现:```javapublicclassBankerAlgorithm{//资源数量和最大需求量privateint[]resource=newint[10];//例如:包括x,y,z三种资源,分别对应i-x1-x2-z...-xi-yi-zi...privateint[]maxDemand=newint[10];privateint[]available=newint[10];//当前可用资源数量privateint[]allocation=newint[10];//当前已分配资源数量privateint[]need=newint[10];//当前进程需求量privateint[]saved=newint[10];//已保存的安全序列中最后一个进程的资源需求量privateint[]process=newint[5];//进程集合,包括进程编号和进程所需资源量privateint[]processMax=newint[5];//进程最大需求量集合privateint[]systemSafe=0;//系统是否处于安全状态的标志位privateinttotalSystemSafe=0;//总共是否有足够资源可以安全运行的标志位//初始化资源分配信息publicvoidinitialize(int[][]allocationMatrix){for(inti=0;i<allocationMatrix.length;i++){process[i]=allocationMatrix[i][0];//进程编号processMax[i]=allocationMatrix[i][1];//进程最大需求量available[i]=allocationMatrix[i][2];//当前可用资源数量need[i]=allocationMatrix[i][3];//当前进程需求量maxDemand[i]=allocationMatrix[i][4];//当前进程最大需求量}systemSafe=true;//系统默认处于安全状态totalSystemSafe=true;//总共是否有足够资源可以安全运行的标志位默认设置为true}//检查系统是否处于安全状态,并返回检查结果和可能的执行序列(从开始到结束)publicboolean[]checkAndPrintSafePath(){intcurrentSystemSafe=false;//检查后的系统是否处于安全状态的标志位boolean[]safePath=newboolean[process.length];//安全序列for(inti=0;i<process.length;i++){if(need[i]<=available[i]){//如果当前进程需要的资源小于等于当前可用资源数量,则可以继续执行下去safePath[i]=true;//将当前进程标记为已执行过,并加入到安全序列中available[i]-=need[i];//将当前可用资源数量减去当前进程的已分配量,表示系统多出来的资源数量为已分配的减去需求的currentSystemSafe=true;//将当前系统的安全状态标记为true,因为已经有至少一个进程能够执行下去了}else{//如果当前进程需要的资源大于当前可用资源数量,则需要检查系统是否有足够的资源可以继续执行下去intavailableSum=0;//系统剩余的可用资源数量之和for(intj=0;j<process.length;j++){//将所有可用资源的数量累加起来availableSum+=available[j];}if(availableSum>=processMax[i]){//如果系统剩余的可用资源数量之和大于等于当前进程的最大需求量,则系统可以继续执行下去,否则需要重新分配资源并返回结果重新开始执行安全序列为null;如果为空说明不满足要求否则输出一个安全的执行序列,开始输出可执行的进程数以及所分配的资源和后续的系统安全状态标记等信息totalSystemSafe=false;//将当前系统安全状态的标志位置为false,因为此时不满足安全状态的要求,需要重新开始执行程序,且此次循环的完整性和执行性需要考虑已经完成过的安全序列重新考虑这些因素的修改可能会被重用)确保安全性序列不再更改);再次输出完整的信息需要重新考虑这些因素以确保安全性序列不再更改)并返回结果;如果为true则说明系统已经处于安全状态并输出一个安全的执行序列;如果为false则说明。
银行家算法实验报告

计算机操作系统实验报告一、实验名称:银行家算法二、实验目的:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计: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;}。
银行家算法java代码

银行家算法java代码银行家算法是一种用于避免死锁的算法,它可以保证系统在分配资源时不会陷入死锁状态。
在操作系统中,银行家算法被广泛应用于进程调度和资源管理中。
本文将介绍银行家算法的原理和实现,并提供Java代码示例。
一、银行家算法原理银行家算法是基于资源分配图的理论基础上发展而来的。
资源分配图是描述进程和资源之间关系的一种图形表示方法。
在资源分配图中,每个进程和每个资源都表示为一个节点,进程需要的资源和已经被占用的资源之间连接一条边。
银行家算法通过模拟进程请求和释放资源的过程来判断是否会出现死锁。
当一个进程请求某些资源时,如果系统能够满足其请求,则该进程可以继续执行;否则,该进程必须等待直到有足够的资源可用。
当一个进程释放掉已经占用的某些资源时,系统会将这些资源重新分配给其他需要它们的进程。
为了避免死锁,银行家算法采取了预防措施:在分配任何一个新任务之前,先检查该任务所需求各类资料是否超过了系统现有的资料总量,如果超过了,则不予分配。
否则,再检查该任务所需求各类资料是否超过了系统现有的未分配资料总量,如果超过了,则不予分配。
二、银行家算法实现银行家算法的实现需要考虑以下几个方面:1.资源分配图的表示方法:可以使用邻接矩阵或邻接表来表示资源分配图。
2.进程请求和释放资源的模拟:可以使用数组来存储进程占用和需要的资源数量,并通过对数组的修改来模拟进程请求和释放资源的过程。
3.死锁检测:可以使用安全序列或银行家算法来判断是否会出现死锁。
下面是一个基于银行家算法实现的简单Java代码示例:public class BankerAlgorithm {// 进程数private int n;// 资源数private int m;// 各进程已占用资源数量private int[][] allocation;// 各进程尚需资源数量private int[][] need;// 系统剩余可用资源数量private int[] available;/*** 构造函数* @param n 进程数* @param m 资源数* @param allocation 各进程已占用资源数量* @param need 各进程尚需资源数量* @param available 系统剩余可用资源数量*/public BankerAlgorithm(int n, int m, int[][] allocation, int[][] need, int[] available) {this.n = n;this.m = m;this.allocation = allocation;this.need = need;this.available = available;}/*** 模拟进程请求资源* @param pid 进程ID* @param request 请求的资源数量* @return 是否满足请求*/public boolean requestResources(int pid, int[] request) { // 检查请求是否超过进程所需的资源数量for (int i = 0; i < m; i++) {if (request[i] > need[pid][i]) {return false;}}// 检查请求是否超过系统剩余的资源数量for (int i = 0; i < m; i++) {if (request[i] > available[i]) {return false;}}// 模拟进程占用资源的过程for (int i = 0; i < m; i++) {available[i] -= request[i];allocation[pid][i] += request[i];need[pid][i] -= request[i];}return true;}/*** 模拟进程释放资源* @param pid 进程ID* @param release 释放的资源数量*/public void releaseResources(int pid, int[] release) { // 模拟进程释放资源的过程for (int i = 0; i < m; i++) {available[i] += release[i];allocation[pid][i] -= release[i];need[pid][i] += release[i];}}/*** 判断系统是否安全* @return 是否安全*/public boolean isSafe() {// 初始化工作数组int[] work = new int[m];for (int i = 0; i < m; i++) {work[i] = available[i];}boolean[] finish = new boolean[n]; for (int i = 0; i < n; i++) {finish[i] = false;}// 查找可用的进程int count = 0;while (count < n) {boolean found = false;for (int i = 0; i < n; i++) {if (!finish[i]) {boolean canRun = true;for (int j = 0; j < m; j++) { if (need[i][j] > work[j]) { canRun = false;break;}}if (canRun) {finish[i] = true;found = true;count++;for (int j = 0; j < m; j++) {work[j] += allocation[i][j];}}}}if (!found) {return false;}}return true;}}三、总结银行家算法是一种重要的避免死锁的算法,它可以在系统分配资源时避免出现死锁状态。
操作系统实验项目银行家算法

实验四、银行家算法(一)目的和要求银行家算法是由Dijkstra设计的最具有代表性的避免死锁的算法。
本实验要求用高级语言编写一个银行家的模拟算法。
通过本实验可以对预防死锁和银行家算法有更深刻的认识。
(二)实验内容1、设置数据结构包括可利用资源向量(Availiable),最大需求矩阵(Max),分配矩阵(Allocation),需求矩阵(Need)2、设计安全性算法设置工作向量Work 表示系统可提供进程继续运行可利用资源数目,Finish 表示系统是否有足够的资源分配给进程(三)实验环境1、pc2、vc++(四)、程序源代码:/*子函数声明*/int Isprocessallover(); //判断系统中的进程是否全部运行完毕void Systemstatus(); //显示当前系统中的资源及进程情况int Banker(int ,int *); //银行家算法void Allow(int ,int *); //若进程申请不导致死锁,用此函数分配资源void Forbidenseason(int ); //若发生死锁,则显示原因/*全局变量*/int Availiable[3]={3,3,2}; //初始状态,系统可用资源量int Max[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//各进程对各资源的最大需求量int Allocation[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//初始状态,各进程占有资源量int Need[5][3]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};//初始状态时,各进程运行完毕,还需要的资源量int over[5]={0,0,0,0,0}; //标记对应进程是否得到所有资源并运行完毕#include <iostream.h>/*主函数*/void main(){int process=0; //发出请求的进程int decide=0; //银行家算法的返回值int Request[3]={0,0,0}; //申请的资源量数组int sourcenum=0; //申请的各资源量/*判断系统中进程是否全部运行完毕*/step1: if(Isprocessallover()==1){cout<<"系统中全部进程运行完毕!";return;}/*显示系统当前状态*/Systemstatus();/*人机交互界面*/step2: cout<<"\n输入发出请求的进程(输入“0”退出系统): ";cin>>process;if(process==0){cout<<"放弃申请,退出系统!";return;}if(process<1||process>5||over[process-1]==1){cout<<"系统无此进程!\n";goto step2;}cout<<"此进程申请各资源(A,B,C)数目:\n";for(int h=0;h<3;h++){cout<<char(65+h)<<"资源:";cin>>sourcenum;Request[h]=sourcenum;}/*用银行家算法判断是否能够进行分配*/decide=Banker(process,Request);if (decide==0){/*将此进程申请资源分配给它*/Allow(process,Request);goto step1;}else{/*不能分配,显示原因*/Forbidenseason(decide);goto step2;}}/*子函数Isprocessallover( )的实现*/int Isprocessallover(){int processnum=0;for(int i=0;i<5;i++){/*判断每个进程是否运行完毕*/if(over[i]==1)processnum++;}if(processnum==5)/*系统中全部进程运行完毕*/return 1;elsereturn 0;}/*子函数Systemstatus( )的实现*/void Systemstatus(){cout<<"此刻系统中存在的进程:\n";for(int i=0;i<5;i++){if(over[i]!=1)cout<<"P"<<i+1<<" ";}cout<<endl;cout<<"此刻系统可利用资源(单位:个):\n";cout<<"A B C\n";for(int a=0;a<3;a++){cout<<Availiable[a]<<" ";}cout<<endl;cout<<"此刻各进程已占有资源如下(单位:个): \n"<<" A B C\n";for(int b=0;b<5;b++){if(over[b]==1)continue;cout<<"P"<<b+1<<" ";for(int c=0;c<3;c++)cout<<Allocation[b][c]<<" ";cout<<endl;}cout<<"各进程运行完毕还需各资源如下(单位:个):\n"<<" A B C\n";for(int f=0;f<5;f++){if(over[f]==1)continue;cout<<"P"<<f+1<<" ";for(int g=0;g<3;g++)cout<<Need[f][g]<<" ";cout<<endl;}}/*子函数Banker(int ,int &)的实现*/int Banker(int p,int *R){int num=0; //标记各资源是否能满足各进程需要int Finish[5]={0,0,0,0,0}; //标记各进程是否安全运行完毕int work[5]={0,0,0,0,0}; //用于安全检查int AvailiableTest[3]; //用于试分配int AllocationTest[5][3]; //同上int NeedTest[5][3]; //同上/*判断申请的资源是否大于系统可提供的资源总量*/for(int j=0;j<3;j++){if(*(R+j)>Availiable[j])/*返回拒绝分配原因*/return 1;}/*判断该进程申请资源量是否大于初始时其申明的需求量*/for(int i=0;i<3;i++){if(*(R+i)>Need[p-1][i])/*返回拒绝原因*/return 2;}/*为检查分配的各数据结构赋初值*/for(int t=0;t<3;t++){AvailiableTest[t]=Availiable[t];}for(int u=0;u<5;u++){for(int v=0;v<3;v++){AllocationTest[u][v]=Allocation[u][v];}}for(int w=0;w<5;w++){for(int x=0;x<3;x++){NeedTest[w][x]=Need[w][x];}}/*进行试分配*/for(int k=0;k<3;k++)//修改NeedTest[]{AvailiableTest[k]-=*(R+k);AllocationTest[p-1][k]+=*(R+k);NeedTest[p-1][k]-=*(R+k);}/*检测进程申请得到满足后,系统是否处于安全状态*/ for(int l=0;l<3;l++){work[l]=AvailiableTest[l];}for(int m=1;m<=5;m++){for(int n=0;n<5;n++){num=0;/*寻找用此刻系统中没有运行完的进程*/if(Finish[n]==0&&over[n]!=1){for(int p=0;p<3;p++){if(NeedTest[n][p]<=work[p])num++;}if(num==3){for(int q=0;q<3;q++){work[q]=work[q]+AllocationTest[n][q];}Finish[n]=1;}}}}for(int r=0;r<5;r++){if(Finish[r]==0&&over[r]!=1)/*返回拒绝分配原因*/return 3;}return 0;}/*子函数Allow(int ,int &)的实现*/void Allow(int p,int *R){cout<<"可以满足申请!";static int overnum;/*对进程所需的资源进行分配*/for(int t=0;t<3;t++){Availiable[t]=Availiable[t]-*(R+t);Allocation[p-1][t]=Allocation[p-1][t]+*(R+t);Need[p-1][t]=Need[p-1][t]-*(R+t);}/*分配后判断其是否运行完毕*/overnum=0;for(int v=0;v<3;v++){if(Need[p-1][v]==0)overnum++;}if(overnum==3){/*此进程运行完毕,释放其占有的全部资源*/for(int q=0;q<3;q++)Availiable[q]=Availiable[q]+Allocation[p-1][q];/*标记该进程运行完毕*/over[p-1]=1;cout<<"进程P"<<p<<"所需资源全部满足,此进程运行完毕!\n";}}/*子函数Forbidenseason(int )的实现*/void Forbidenseason(int d){cout<<"不能满足申请,此进程挂起,原因为:\n";switch (d){case 1:cout<<"申请的资源量大于系统可提供的资源量!";break;case 2:cout<<"申请的资源中有某种资源大于其声明的需求量!";break;case 3:cout<<"若满足申请,系统将进入不安全状态,可能导致死锁!";}}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
(1)设置两个向量:
工作向量Work,他表示系统可提供给进程继续运行所需的各类资源数目,它含有m个元素,在执行安全算法开始时,Work:=Available.
Finish,他表示系统是否有足够的资源分配给进程,使之运行完成。开始时先做Finish[i]:=flase;当有足够资源分配给进程后,再令Finish[i]:=True.
Finish[i]:=true;
go to step 2;
(4)如果所有进程的Finish[i]=true都满足,则表示系统处于安全状态;否则,系统处于不安全状态。
5.4 具体模块设计
图5-4-!安全性算法流程图
6.
(1)测试数据:
根据主界面提示,输入资源的名称数量和进程的数量以及进程所需的最大需求量和已分配的资源,然后进行观察。
银行家算法分配资源的原则是:系统掌握每个进程对资源的最大需求量,当进程要求申请资源时,系统就测试该进程尚需资源的最大量,如果系统中现存的资源数大于或等于该进程尚需求资源最大量时,就满足进程的当前申请。这样就可以保证至少有一个进程可能得到全部资源而执行到结束,然后归还它所占有的全部资源供其它进程使用。
int Need[50][50]={0};
int Request[50]={0};
int Work[50]={0};
char name[100]={0};
int temp[50]={0};
int Finish[50]={0};
5.2 系统函数详细介绍
void showdata()
此函数主要是在确定好资源和进程以及各进程的最大需求量和已分配的资源后,显示的此刻资源的分配情况。
【2】史美林编.计算机操作系统教程.北京:清华大学出版社,1999.11
【3】徐甲同编著.操作系统教程.西安:西安电子科技大学出版社,1996.8
【4】Clifford,A.Shaffer编著.数决结构与算法分析(C++版).北京:电子工业出版社,2005.7
【5】蒋立翔编著.C++程序设计技能百练.北京:中国铁道出版社,2004.1
关键字:死锁,安全序列,银行家算法进程
10.程序源代码11
《操作系统》课程设计
银行家算法
1.
“操作系统”是计算机专业的核心专业课,“操作系统课程设计”是理解和巩固操作系统基本理论、原理和方法的重要的实践环节。
操作系统课程主要讲述的内容是多道操作系统的原理与技术,与其它计算机原理、编译原理、汇编语言、计算机网络、程序设计等专业课程关系十分密切。本课程设计的目的综合应用学生所学知识,建立系统和完整的计算机系统概念,理解和巩固操作系统基本理论、原理和方法,掌握操作系统基本理论与管理方式。在算法基础上,解决实际的管理功能的问题,提高学生实际应用、编程的能力。
课程设计(论文)
题目:银行家算法
院(系):信息与控制工程系
专业班级:
姓名:
学号:
指导教师:
2016年1月15日
西安建筑科技大学华清学院课程设计(论文)任务书
专业班级:学生姓名:指导教师(签名):
一、课程设计(论文)题目
银行家算法:设计一个n个并发进程共享m个系统资源的程序以实现银行家算法。
二、本次课程设计(论文)应达到的目的
三、本次课程设计(论文)任务的主要内容和要求(包括原始数据、技术参数、设计要求等)
要求:
1)能显示当前系统资源的占用和剩余情况。
2)为进程分配资源,如果进程要求的资源大于系统剩余的资源,不与分配并且提示分配不成功;
3)撤销作业,释放资源。
编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用适当的算法,有效地防止和避免死锁的发生。
void share()
此函数对申请的资源进行判定,如果合法,则予以分配;如果出错,则不给分配。
int safe()
此函数当为进程分配资源以后,检查这个状态是不是安全的,如安全,则确认分配;否则不予分配。
5.3 系统功能模块介绍
显示模块:此模块主要是显示某时刻的资源分配情况。
银行家算法模块:由银行家算法对资源进行分配,算法如下:
int Allocation[50][50]={0};
int Need[50][50]={0};
int Request[50]={0};
int Work[50]={0};
char name[100]={0};
int temp[50]={0};
int Finish[50]={0};
int M=50; // 作业最大数
操作系统课程实践性比较强。课程设计是加强学生实践能力的一个强有力手段。课程设计要求学生在完成程序设计的同时能够写出比较规范的设计报告。严格实施课程设计这一环节,对于学生基本程序设计素养的培养和软件工作者工作作风的训练,将起到显著的促进作用。
本题目要达到目的:了解多道程序系统中,多个进程并发执行的资源分配。掌握银行家算法,了解资源在进程并发执行中的资源分配情况。掌握预防死锁的方法,系统安全状态的基本概念。
4.3 函数间的关系
此系统各个函数之间相互是有联系的,比如在主函数中会调用其他的函数,在share函数中也对前面两个函数进行了调用。
4.4 系统功能模块图
图4-4-1系统功能模块图
5.
5.1 结构体的详细定义
int Available[50]={0};
int Max[50][50]={0};
int Allocation[50][50]={0};
Available[j]:= Available[j]—Requesti[j];
Allocation[i,j]:=Allocation[i,j]+Requesti[j];
Need[i,j]:= Need[i,j]—Requesti[j];
(4)系统执行安全性算法,检查此次资源分配后系统是否处于安全状态。若安全,才正式将资源分配给进程Pi,以完成本次分配;否则,将本次的试探分配作废,恢复原来的资源分配状态,让进程Pi等待。
课程设计几天的时间下来,对操作系统这门课有了更深的了解,它是一门很重要的课程,算法比较多,需要我们很好地去掌握。而且在过程当中,我们也好地复习了c语言这门课,在计算机领域,很多课程都是相互联系的,相互交叉的,所以我们应该认真地对待每一门课程。这次的课设让我明白,以后一定要自己多动手做,这样才能印象深刻,才能更好地掌握这门课。
【5】蒋立翔编著.C++程序设计技能百练.北京:中国铁道出版社,2004.1
10
#include<stdio.h>
#include<iostream.h>
#include<string.h>
#define false 0
#define true 1
int Available[50]={0};
int Max[50][50]={0};
(1)如果Requesti[j]<or=Need[i,j],便转向步骤2;否则认为出错,因为它所需要的资源数已超过它所宣布的最大值。
(2)如果Requesti[j]<or=Available[j], 便转向步骤3,否则,表示尚无足够资源,Pi需等待。
(3)系统试探着把资源分配给进程Pi,并修改下面数据结构中的数值:
3.
3.1 数据需求
系统可分配资源量,进程已申请到的资源量,进程所需最大资源量,进程还需要的资源量
3.2 基本功能需求
此系统主要通过银行家算法为进程进行资源的分配。
3.3 非功能性需求
用户界面需求:简洁、易用、易懂、友好的用户界面。
硬件要求:装有Visual C++6.0的计算机。
可靠性需求:保证用户在正常使用本系统时,用户的操作或误操作不会产生数据的丢失。
int N=50; //资源最大数
void showdata()
{int i,j;
cout<<"此时刻的资源分配情况为:"<<endl;
cout<<endl;
cout<<" Max Allocation Need Available "<<endl;
cout<<"进程名 ";
for(j=0;j<4;j++)
4.概要设计
4.1 数据结构
数组:
可利用资源向量Available 最大需求矩阵Max
分配矩阵Allocation 需求矩阵Need
4.2 系统包含的函数
void showdata(); //显示主界面函数
int safe(); //安全性算法函数
void share(); //银行家算法
int main();//主函数
{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<<" ";
(2)算法改进设想:
在程序设计前期,代码运行语法部分没有出现问题,但是在运行时,在输入已分配资源那块出现问题,经过不断地修改和请教,终于成功运行出来。