银行家算法模拟(操作系统原理,C++语言)

合集下载

操作系统实验银行家算法模拟实现(强烈推荐)

操作系统实验银行家算法模拟实现(强烈推荐)

实验八银行家算法模拟实现一.实验目的1)理解死锁避免相关内容;2)掌握银行家算法主要流程;3)掌握安全性检查流程。

二.实验描述本实验主要对操作系统中的死锁预防部分的理论进行实验。

要求实验者设计一个程序,该程序可对每一次资源申请采用银行家算法进行分配。

三.实验内容1)设计多个资源(≥3);2)设计多个进程(≥3);3)设计银行家算法相关的数据结构;4)动态进行资源申请、分配、安全性检测并给出分配结果。

四.实验要求1)编写程序完成实验内容;2)画出安全性检测函数流程图;3)小组派1人上台用PPT演讲实现过程;4)撰写实验报告。

测试要求1)进行Request请求,输入参数为进程号、资源号和资源数;2)进行3次以上的Request请求;3)至少进行1次资源数目少于可用资源数,但不安全的请求。

五.实验设备PC机1台,要求安装DOS7.1、Turbo C3.0、Windows2000。

六.实验结果七.实验思考1)针对死锁有哪些可行方案?2)死锁解除的难点是什么?八.银行家算法介绍8.1银行家算法的数据结构1)可利用资源向量Available。

其中每个元素代表每类资源的数目。

2)最大需求矩阵Max。

其中每个元素代表每个进程对于每类资源的最大需求量。

Max[i,j]=K表示i进程对于j类资源的最大需求量为K。

3)分配矩阵Allocation。

其中每个元素代表每个进程已得到的每类资源的数目。

4)需求矩阵Need。

其中每个元素代表每个进程还需要的每类资源的数目。

8.2银行家算法Request i [j]=K表示进程Pi需要K个j类资源。

1)如果Request i [j]≤Need[i , j],便转向步骤2,否则认为出错。

2)如果Request i [j]≤Available[j],便转向步骤3,否则表示无足够资源,Pi需等待;3)系统尝试分配资源给Pi;4)系统进行安全性检查,检查此次资源分配后,系统是否安全。

如果安全,则正式分配资源,否则撤销此次分配。

编程序模拟银行家算法

编程序模拟银行家算法

武汉理工大学华夏学院课程设计报告书课程名称:操作系统原理题目:编程序模拟银行家算法系名:信息工程系专业班级:软件1121*名:**学号:***************:***2014年 6 月13 日武汉理工大学华夏学院信息工程系课程设计任务书课程名称:操作系统原理课程设计指导教师:苏永红班级名称:软件1121 开课系、教研室:软件与信息安全一、课程设计目的与任务操作系统课程设计是《操作系统原理》课程的后续实践课程,旨在通过一周的实践训练,加深学生对理论课程中操作系统概念,原理和方法的理解,加强学生综合运用操作系统原理、Linux系统、C语言程序设计技术进行实际问题处理的能力,进一步提高学生进行分析问题和解决问题的能力,包含系统分析、系统设计、系统实现和系统测试的能力。

学生将在指导老师的指导下,完成从需求分析,系统设计,编码到测试的全过程。

二、课程设计的内容与基本要求1、课程设计题目编程序模拟银行家算法2、课程设计内容本课程设计要求在Linux操作系统,GCC编译环境下开发。

银行家算法是避免死锁的一种重要方法,本实验要求用用c/c++语言在Linux操作系统环境下编写和调试一个简单的银行家算法程序。

加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

思想:将一定数量的资金供多个用户周转使用,当用户对资金的最大申请量不超过现存资金时可接纳一个新客户,客户可以分期借款,但借款总数不能超过最大的申请量。

银行家对客户的借款可以推迟支付,但是能够使客户在有限的时间内得到借款,客户得到所有的借款后能在有限的时间内归还。

用银行家算法分配资源时,测试进程对资源的最大需求量,若现存资源能满足最大需求就满足当前进程的申请,否则推迟分配,这样能够保证至少有一个进程可以得到所需的全部资源而执行到结束,然后归还资源,若OS能保证所有进程在有限的时间内得到所需资源则称系统处于安全状态。

3、设计报告撰写格式要求:1设计题目与要求 2 设计思想3系统结构 4 数据结构的说明和模块的算法流程图5 使用说明书(即用户手册):内容包含如何登录、退出、读、写等操作说明6 运行结果和结果分析(其中包括实验的检查结果、程序的运行情况)7 自我评价与总结8 附录:程序清单,注意加注释(包括关键字、方法、变量等),在每个模块前加注释;三、课程设计步骤及时间进度和场地安排本课程设计将安排在第17周, 教育技术中心。

操作系统实验报告--C语言实现银行家算法

操作系统实验报告--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、检测系统资源分配是否安全结果。

操作系统实验六(编程模拟实现银行家算法)

操作系统实验六(编程模拟实现银行家算法)

实验六编程模拟实现银行家算法(综合性编程实验4学时)一. 目的要求通过对银行家算法的模拟,了解死锁概念、死锁的本质以及掌握解决死锁的方法。

二.实验任务编程模拟银行家算法中的安全性算法,系统当前状态(最大资源需求、进程已占有的资源、进程还需要的资源)以某种形式输入,程序输出是否安全和不安全的结果。

三.实验环境、设备硬件:586以上的PC系列机,主频大于166M,内存大于16MB,硬盘空闲空间大于500MB。

软件:选择一个自己熟悉的计算机操作系统(如DOS、Windows98/2000/XP、UNIX、linux等,根据各学校的条件与环境而定)和程序设计语言(如Turbo C、C语言、PASCAL语言等)。

编程语言由各位同学自己选择确定,不做统一规定。

四.实验指导模拟银行家算法中的安全性算法,系统当前状态(最大资源需求。

进程已占有的资源、进程还需要的资源)以某种形式输入,程序输出是否安全和不安全的结果。

为简单以见,以教材中的例子做为输入,实现安全性算法。

1.主要数据结构①可用资源数组work,它的长度为资源类型数2,如果work [1]= k表示当前状态下B种资源的可用个数为k个。

例:work[1]=3,表示B类资源当前空闲3台。

②分配矩阵allo(alloction),它是一个[5,2]的矩阵,allo [3,1]= k表示第4个进程已分配k个B类型的资源数.③剩余需求矩阵need,它是一个[5,2]的矩阵,need[3,1]=k表示第4个进程还需要k个B类型的资源数.④系统拥有资源向量max,它的长度为资源类型数2,如果max [1]= k,表示系统中拥有B种资源数为k个.⑤安全状态标示数组finish,他的长度为进程个数5,用它来表示当前状态下系统是否有足够资源分配给该进程。

2.程序说明该程序对于每一种资源进行安全检验,进行检验的算法详见《操作系统》,该程序没有实现每个进程在系统安全时进行动态的分配资源,而是在静态的条件下输入系统的状态,和每个进程拥有.资源的状态,来判断系统是否安全.因此在程序中定义的request矩阵,没有起到作用.如要实规模拟动态的资源分配,在该程序的基础上稍加改动即可.五.实验源代码import java.util.*;public class os{public static void main(String args[]){int max[][]={{7,5},{3,2},{9,0},{2,2},{4,3}};int allo[][]={{0,1},{2,0},{3,0},{2,1},{0,0}};int need[][]={{7,4},{1,2},{6,0},{0,1},{4,3}};int work[]={3,3};boolean finish[]={false,false,false,false,false};int count=5;int i;while(count>0){for( i=0;i<5;i++){if(finish[i]==false&&need[i][0]<=work[0]&&need[i][1]<=work[1]){work[0]+=allo[i][0];work[1]+=allo[i][1];finish[i]=true;count--;break;}}}if(count==0)System.out.println("系统安全!");elseSystem.out.println("系统不安全!");} }。

操作系统课程设计银行家算法参考

操作系统课程设计银行家算法参考

3 课程设计三银行家算法(参考1)1设计目的(1)了解多道程序系统中,多个进程并发执行的资源分配。

(2)掌握死锁产生的原因、产生死锁的必要条件和处理死锁的基本方法。

(3)掌握预防死锁的方法,系统安全状态的基本概念。

(4)掌握银行家算法,了解资源在进程并发执行中的资源分配策略。

(5)理解避免死锁在当前计算机系统不常使用的原因。

2.算法描述Dijkstra(1965年)提出了一种能够避免死锁的调度方法,称为银行家算法,它的模型基于一个小城镇的银行家,现将该算法描述如下:假定一个银行家拥有资金,数量为Σ,被N个客户共享。

银行家对客户提出下列约束条件:(1)每个客户必须预先说明自已所要求的最大资金量;(2)每个客户每次提出部分资金量申请各获得分配;(3)如果银行满足了客户对资金的最大需求量,那么,客户在资金动作后,应在有限时间内全部归还银行。

只要每个客户遵守上述约束,银行家将保证做到:若一个客户所要求的最大资金量不超过Σ,则银行一定接纳该客户,并可处理他的资金需求;银行在收到一个客户的资金申请时,可能因资金不足而让客户等待,但保证在有限时间内让客户获得资金。

在银行家算法中,客户可看做进程,资金可看做资源,银行家可看做操作系统。

3. 环境操作系统Windows XP SP2,开发工具VC++6.0或者BCB6.0。

4 功能模块说明1.银行家所能够提供的资源typedef struct node{int a;int b;int c;int remain_a;int remain_b;int remain_c;}bank;2.进程所占用的资源typedef struct node1{char name[20];int a;int b;int c;int need_a;int need_b;int need_c;}process;main()函数:完成对系统运行环境的初始化,定义了简单的选择菜单,调用各功能函数。

实验七 银行家算法模拟实验

实验七  银行家算法模拟实验

实验七银行家算法模拟实验一、实验目的(1)进一步理解利用银行家算法避免死锁的问题;(2)在了解和掌握银行家算法的基础上,编写银行家算法通用程序,友好显示调试结果;(3)理解和掌握安全序列、安全性算法。

二、实验环境(1)装有Microsoft Visual Studio C++6.0专业版或企业版。

三、实验内容及原理(一)实验内容理解什么是死锁?理解利用银行家算法避免死锁的原理;会使用某种编程语言模拟实验银行家算法。

(二)实验原理1、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列),为每个进程分配所需的资源,直至最大需求,使得每个进程都能顺利完成。

2、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后,表示为Requesti[j]=k。

系统按下述步骤进行安全检查:(1)如果Request i[]≤Need[]则继续以下检查,否则显示需求申请超出最大需求值的错误。

(2)如果Request i[]≤Available[]则继续以下检查,否则显示系统无足够资源,Pi阻塞等待。

(3)系统试探着把资源分配给进程Pi,并修改下面数据结构中的数值: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等待。

3、安全性算法(1)设置两个向量:①工作向量Work:它表示系统可提供给进程继续运行所需的各类资源数目,它含有m 个元素,在执行安全算法开始时,Work:=Available;②Finish:它表示系统是否有足够的资源分配给进程,使之运行完成。

银行家算法用C语言编写.全部程序

银行家算法用C语言编写.全部程序

银行家算法银行家算法是一种最有代表性的避免死锁的算法。

要解释银行家算法,必须先解释操作系统安全状态和不安全状态。

安全状态:如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态。

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

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

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

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

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

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

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

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

算法:n:系统中进程的总数m:资源类总数Available: ARRAY[1..m] of integer;Max: ARRAY[1..n,1..m] of integer;Allocation: ARRAY[1..n,1..m] of integer;Need: ARRAY[1..n,1..m] of integer;Request: ARRAY[1..n,1..m] of integer;符号说明:Available 可用剩余资源Max 最大需求Allocation 已分配资源Need 需求资源Request 请求资源当进程pi提出资源申请时,系统执行下列步骤:(“=”为赋值符号,“==”为等号)step(1)若Request<=Need, goto step(2);否则错误返回step(2)若Request<=Available, goto step(3);否则进程等待step(3)假设系统分配了资源,则有:Available=Available-Request;Allocation=Allocation+Request;Need=Need-Request若系统新状态是安全的,则分配完成若系统新状态是不安全的,则恢复原状态,进程等待为进行安全性检查,定义数据结构:Work:ARRAY[1..m] of integer;Finish:ARRAY[1..n] of Boolean;安全性检查的步骤:step (1):Work=Available;Finish=false;step (2) 寻找满足条件的i:a.Finish==false;b.Need<=Work;如果不存在,goto step(4)step(3)Work=Work+Allocation;Finish=true;goto step(2)step (4) 若对所有i,Finish=true,则系统处于安全状态,否则处于不安全状态/* 银行家算法,操作系统概念(OS concepts Six Edition)reedit by Johnny hagen,SCAU,run at vc6.0*/#include "malloc.h"#include "stdio.h"#include "stdlib.h"#define alloclen sizeof(struct allocation)#define maxlen sizeof(struct max)#define avalen sizeof(struct available)#define needlen sizeof(struct need)#define finilen sizeof(struct finish)#define pathlen sizeof(struct path)struct allocation{int value;struct allocation *next;};struct max{int value;struct max *next;};struct available /*可用资源数*/{int value;struct available *next;};struct need /*需求资源数*/{int value;struct need *next;};struct path{int value;struct path *next;};struct finish{int stat;struct finish *next;};int main(){int row,colum,status=0,i,j,t,temp,processtest;struct allocation *allochead,*alloc1,*alloc2,*alloctemp;struct max *maxhead,*maxium1,*maxium2,*maxtemp;struct available*avahead,*available1,*available2,*workhead,*work1,*work2,*worktemp,*worktemp1; struct need *needhead,*need1,*need2,*needtemp;struct finish *finihead,*finish1,*finish2,*finishtemp;struct path *pathhead,*path1,*path2;printf("\n请输入系统资源的种类数:");scanf("%d",&colum);printf("请输入现时内存中的进程数:");scanf("%d",&row);printf("请输入已分配资源矩阵:\n");for(i=0;i<row;i++){for (j=0;j<colum;j++){printf("请输入已分配给进程p%d 的%c 种系统资源:",i,'A'+j);if(status==0){allochead=alloc1=alloc2=(struct allocation*)malloc(alloclen);alloc1->next=alloc2->next=NULL;scanf("%d",&allochead->value);status++;}else{alloc2=(struct allocation *)malloc(alloclen);scanf("%d,%d",&alloc2->value);if(status==1){allochead->next=alloc2;status++;}alloc1->next=alloc2;alloc1=alloc2;}}}alloc2->next=NULL;status=0;printf("请输入最大需求矩阵:\n");for(i=0;i<row;i++){for (j=0;j<colum;j++){printf("请输入进程p%d 种类%c 系统资源最大需求:",i,'A'+j); if(status==0){maxhead=maxium1=maxium2=(struct max*)malloc(maxlen); maxium1->next=maxium2->next=NULL;scanf("%d",&maxium1->value);status++;}else{maxium2=(struct max *)malloc(maxlen);scanf("%d,%d",&maxium2->value);if(status==1){maxhead->next=maxium2;status++;}maxium1->next=maxium2;maxium1=maxium2;}}maxium2->next=NULL;status=0;printf("请输入现时系统剩余的资源矩阵:\n");for (j=0;j<colum;j++){printf("种类%c 的系统资源剩余:",'A'+j);if(status==0){avahead=available1=available2=(struct available*)malloc(avalen); workhead=work1=work2=(struct available*)malloc(avalen); available1->next=available2->next=NULL;work1->next=work2->next=NULL;scanf("%d",&available1->value);work1->value=available1->value;status++;}else{available2=(struct available*)malloc(avalen);work2=(struct available*)malloc(avalen);scanf("%d,%d",&available2->value);work2->value=available2->value;if(status==1){avahead->next=available2;workhead->next=work2;status++;}available1->next=available2;available1=available2;work1->next=work2;work1=work2;}}available2->next=NULL;work2->next=NULL;status=0;alloctemp=allochead;maxtemp=maxhead;for(i=0;i<row;i++)for (j=0;j<colum;j++)if(status==0){needhead=need1=need2=(struct need*)malloc(needlen); need1->next=need2->next=NULL;need1->value=maxtemp->value-alloctemp->value; status++;}else{need2=(struct need *)malloc(needlen);need2->value=(maxtemp->value)-(alloctemp->value);if(status==1){needhead->next=need2;status++;}need1->next=need2;need1=need2;}maxtemp=maxtemp->next;alloctemp=alloctemp->next;}need2->next=NULL;status=0;for(i=0;i<row;i++){if(status==0){finihead=finish1=finish2=(struct finish*)malloc(finilen); finish1->next=finish2->next=NULL;finish1->stat=0;status++;}else{finish2=(struct finish*)malloc(finilen);finish2->stat=0;if(status==1){finihead->next=finish2;status++;finish1->next=finish2;finish1=finish2;}}finish2->next=NULL; /*Initialization compleated*/status=0;processtest=0;for(temp=0;temp<row;temp++){alloctemp=allochead;needtemp=needhead;finishtemp=finihead;worktemp=workhead;for(i=0;i<row;i++){worktemp1=worktemp;if(finishtemp->stat==0){for(j=0;j<colum;j++,needtemp=needtemp->next,worktemp=worktemp->next) if(needtemp->value<=worktemp->value)processtest++;if(processtest==colum){for(j=0;j<colum;j++){worktemp1->value+=alloctemp->value;worktemp1=worktemp1->next;alloctemp=alloctemp->next;}if(status==0){pathhead=path1=path2=(struct path*)malloc(pathlen);path1->next=path2->next=NULL;path1->value=i;status++;}else{path2=(struct path*)malloc(pathlen);path2->value=i;if(status==1)pathhead->next=path2;status++;}path1->next=path2;path1=path2;}finishtemp->stat=1;}else{for(t=0;t<colum;t++)alloctemp=alloctemp->next; finishtemp->stat=0;}}elsefor(t=0;t<colum;t++){needtemp=needtemp->next; alloctemp=alloctemp->next;}processtest=0;worktemp=workhead;finishtemp=finishtemp->next;}}path2->next=NULL;finishtemp=finihead;for(temp=0;temp<row;temp++) {if(finishtemp->stat==0){printf("\n系统处于非安全状态!\n"); exit(0);}finishtemp=finishtemp->next;}printf("\n系统处于安全状态.\n"); printf("\n安全序列为: \n");do{printf("p%d ",pathhead->value); }while(pathhead=pathhead->next); printf("\n");return 0;}。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

操作系统课程设计模拟银行家算法避免死锁

操作系统课程设计模拟银行家算法避免死锁

模拟通过银行家算法避免死锁一、银行家算法产生(de)背景及目(de)1:在多道程序系统中,虽然借助于多个进程(de)并发执行来改善系统(de)利用率,提高系统(de)吞吐量,但可能发生一种危险—死锁.死锁就是多个进程在运行过程中因争夺资源而造成(de)一种僵局,当进程处于这种僵局状态时,如无外力作用,他们将无法再向前进行,如再把信号量作为同步工具时,多个Wait和Signal操作顺序不当,会产生进程死锁.然而产生死锁(de)必要条件有互斥条件,请求和保持条件,不剥夺条件和环路等待条件.在预防死锁(de)几种方法中,都施加了较强(de)限制条件,在避免死锁(de)方法中,所施加(de)条件较弱,有可能获得令人满意(de)系统性能.在该方法中把系统(de)状态分为安全状态和不安全状态,只要能使系统都处于安全状态,便可避免死锁.2:实验目(de):让学生独立(de)使用编程语言编写和调试一个系统分配资源(de)简单模拟程序,了解死锁产生(de)原因及条件.采用银行家算法及时避免死锁(de)产生,进一步理解课堂上老师讲(de)相关知识点.银行家算法是从当前状态出发,逐个按安全序列检查各客户中谁能完成其工作,然后假定其完成工作且归还全部贷款,再进而检查下一个能完成工作(de)客户.如果所有客户都能完成工作,则找到一个安全序列,银行家才是安全(de).二:银行家算法中(de)数据结构1:可利用资源向量Available.这是一个含有m个元素(de)数组,其中(de)每个元素代表一类可利用(de)资源数目,其初始值是系统中所配置(de)该类全部可用资源(de)数目,其数值随该类资源(de)分配和回收而动态(de)改变.如果Available[j]=k,z则表示系统中现有Rj类资源K 个.2:最大需求矩阵Max.这是一个nm(de)矩阵,它定义了系统中n个进程中(de)每一个进程对m类资源(de)最大需求.如果Max[i,j]=k,表示第i个进程需要第Rj类资源(de)最大数目k个.3: 分配矩阵Allocation,也是nm(de)矩阵,若Allocation[i,j]=k,表示第i个进程已分配Rj类资源(de)数目为k个.4:需求矩阵Need.也是一个nm(de)矩阵,Need[i,j]=k,表示第i个进程还需Rj类资源k个.三、银行家算法及安全性算法1:银行家算法设Request[i]是进程Pi(de)请求向量,若Request[i][j]=k;表示进程需要j类资源k个.当Pi发出资源请求时,系统按下属步骤进行检查;(1)如果Request[i][j]<=Need[i][j];便转向步骤(2),否则认为出错,因为它所需要(de)资源数已超过他所宣布(de)最大值.(2)如果Request[i][j]<=Available[i][j],便转向步骤(3),否则认为尚无足够资源,进程需等待.(3)系统试探着把资源分配给进程,并修改下面数据结构(de)数据Available[i][j]=Available[i][j]-Request[i][j];Allocation[i][j]=Allocation[i][j]+Request[i][j];Need[i][j]=Need[i][j]-Request[i][j];(4)系统执行安全性算法,检查此次资源分配后系统是否处于安全状态.若安全,才正式将资源分配给进程Pi,已完成此次分配.否则,将本次(de)试探分配作废,回复原来(de)资源分配状态,将进程Pi等待.2:安全性算法(1)设置两个向量;1:工作向量Work,表示系统可提供给进程运行所需(de)各类资源数目,它含有m个元素,初始时Work=Available2:Finish ,表示系统是否有足够(de)资源分配给进程,使之运行完成.开始时先做Finish[i]=true(2)从进程中找到一个能满需下属条件(de)进程1;Finish[i]=false;2:Need[i][j]<=Work[j];若找到执行步骤(3),否则执行步骤(4)(3)当进程Pi顺利获得资源后,直至完成,并释放分配给它(de)资源,执行:Work[j]=Work[j]+Allocation[i][j];Finish[i]=true;Go to step (2);(5)如果所有(de)进程Finish[i]都满足,则表示系统处于安全状态,否则,处于不安全状态.四、模块设计与分析及整体功能概述模块设计与分析:整个银行家算法分为初始化函数Init(),安全性算法函数 safe(),银行家算法函数bank()三部分.初始化函数生成开始时刻系统中(de)进程和资源情况,安全性算法判断当某进程申请资源时,系统能否处于安全状态.在本实验中,若系统处于安全状态,便生成一个安全进程序列(安全序列可能有多个).银行家算法函数bank()负责整体(de)检查与异常判断.整体功能概述:死锁会引起系统陷入僵局,操作系统必须防止此现象(de)发生.本实验通过一个动态分配资源(de)模拟程序,更清楚(de)理解死锁产生(de)原因和条件.Dijkstra(de)银行家算法是最有代表性(de)避免死锁(de)方法.运行程序时用户设定系统中进程和可利用资源(de)种类数目.输入各进程(de)可利用资源Available,最大需求MAX,已分配资源Allocation ,需求资源Need,之后各系统发出资源请求Request,利用实验中(de)安全性算法判断能否产生一个安全性队列,若能,则给该进程分配成功,否则,不予分配.五、流程图设计六、源代码及调试分析include<>define MAXm 50用Vc++编译程序编写银行家算法,进一步理解到通过银行家算法避免死锁(de)思想,同时也理解了系统死锁产生(de)原因及条件.2.在实验过程中所有(de)设计步骤遵循老师教授(de)程序功能化(de)思想,分别定义了三个函数,init()初始化函数,safealg()安全性算法函数,bank()银行家算法函数,体现了函数(de)模块化思想.这样(de)话,不仅提高了程序(de)可读性和可操作性,而且还提高了CPU(de)利用率和内存(de)利用率,因为程序(de)运行是局部性(de),这种思想对于段页式存储管理系统尤为重要.3.实验过程中遇到(de)种种疑难问题通过自己上网查找答案,锻炼了自己纠错能力和搜索有价值信息(de)能力及自学(de)能力,并且进一步巩固了自己以前学过(de)专业知识.。

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

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

银行家算法实验报告c语言银行家算法实验报告引言:计算机科学中的银行家算法是一种资源分配和避免死锁的算法。

它是由艾德加·戴克斯特拉(Edsger Dijkstra)在1965年提出的。

银行家算法通过判断一个系统是否处于安全状态来决定是否分配资源给进程。

本实验旨在使用C语言实现银行家算法,并通过一系列的实例来验证其有效性。

一、实验背景银行家算法是为了解决资源分配中的死锁问题而提出的。

在多进程系统中,每个进程都需要一定数量的资源来完成任务。

然而,如果资源分配不当,可能会导致死锁的发生,即所有进程都陷入无法继续执行的状态。

银行家算法通过合理地分配资源,避免了死锁的发生。

二、实验目的本实验的主要目的是通过C语言实现银行家算法,并通过实例验证其正确性和有效性。

具体而言,我们将模拟一个系统中的多个进程,并为每个进程分配资源。

然后,我们将使用银行家算法来判断系统是否处于安全状态,从而决定是否继续分配资源。

三、实验过程1. 创建进程和资源我们首先创建了5个进程和3种资源。

每个进程需要的资源数量是随机生成的,以模拟真实情况下的资源需求。

2. 分配资源根据银行家算法的原则,我们按照以下步骤来分配资源:- 首先,检查每个进程的资源需求是否小于等于系统当前可用的资源数量。

- 如果满足条件,将资源分配给该进程,并更新系统剩余资源数量。

- 如果不满足条件,暂时不分配资源给该进程,继续检查下一个进程。

3. 判断系统状态在每次资源分配后,我们需要判断系统是否处于安全状态。

为此,我们使用银行家算法的核心原则:只有当系统能够为每个进程提供所需的资源时,系统才是安全的。

我们通过遍历所有进程来检查其资源需求是否小于等于系统剩余资源数量,如果满足条件,说明系统是安全的。

4. 实例验证我们进行了多个实例验证,以确保银行家算法的正确性。

在每个实例中,我们模拟了不同的进程和资源需求,并观察系统的状态。

通过比较实验结果和预期结果,我们验证了银行家算法的有效性。

操作系统实验报告(银行家算法c语言描述)

操作系统实验报告(银行家算法c语言描述)
do{
Inint(&processNum, &resourceNum);
printf("T0时刻安全性:");
if(safe(processNum, resourceNum))
{
isSafe=true;
printf("存在安全序列故系统是安全的!\n安全序列为:");
for(inti=0;i<processNum;++i)
{
if(Need[j][k]<=Work[k])
{
++count;
}
}
if(count==resourceNum)
{
for(intk=0;k<resourceNum;++k)
{
tempWork[j][k]=Work[k];
Work[k]=Work[k]+Allocation[j][k];
}
Finish[j]=true;
{intnum,typ源自;printf("输入进程数量和资源种类:");
scanf("%d%d",&num,&type);
*processNum=num;
*resourceNum=type;
printf("输入各类资源可用量:");
for(intj=0;j<type;++j)
{
scanf("%d",&Available[j]);
boolsafe(int,int);
boolIsValidate(int,int*,int,int);
voiddisplayInfo(int,int);

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

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

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

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

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

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

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

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

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

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

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

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

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

银行家算法(用C语言实现)课程设计报告

银行家算法(用C语言实现)课程设计报告

课程设计报告题目银行家算法程序设计课程名称操作系统课程设计院部名称信息技术学院专业计算机科学与技术班级学生姓名* *学号**********课程设计地点课程设计学时20指导教师* ********教务处制操作系统课程设计报告摘要Dijkstra提出的银行家算法,是最具代表性的避免死锁的算法。

本文对如何用银行家算法来处理操作系统给进程分配资源做了详细的说明,包括需求分析、概要设计、详细设计、测试与分析、总结、源程序清单。

首先做了需求分析,解释了什么是银行家算法,并指出它在资源分配中的重要作用。

然后给出了银行家算法的概要设计,包括算法思路、步骤,以及要用到的主要数据结构、函数模块及其之间的调用关系等。

在概要设计的基础上,又给出了详细的算法设计,实现概要设计中定义的所有函数,对每个函数写出核心算法,并画出了流程图。

接着对编码进行了测试与分析(并在最后附上Java编写的程序代码)。

最后对整个设计过程进行了总结。

关键词:安全状态;安全序列;银行家算法;安全性算法;安全序列;流程图。

目录摘要 (1)目录 (2)1.绪论 (3)1.1前言 (3)1.2研究意义 (4)1.3结构安排 (4)2.需求分析 (5)2.1题目描述 (5)2.2银行家算法 (5)2.3基本要求 (5)2.4目的 (6)3.概要设计 (7)3.1设备环境 (7)3.2算法思路 (7)3.3银行家算法步骤 (7)3.4安全性算法步骤 (8)3.5数据结构 (9)3.6系统结构图 (12)4.详细设计 (13)4.1主要函数的核心代码 (13)4.2程序流程图 (13)5.测试 (16)5.1测试用例 (16)5.2测试结果截图 (17)6.总结 (22)参考文献 (24)致谢 (25)附录 (26)1绪论1.1前言:Dijkstra (1965)提出了一种能够避免死锁的调度算法,称为银行家算法。

它的模型基于一个小城镇的银行家,他向一群客户分别承诺了一定的贷款额度,每个客户都有一个贷款额度,银行家知道不可能所有客户同时都需要最大贷款额,所以他只保留一定单位的资金来为客户服务,而不是满足所有客户贷款需求的最大单位。

操作系统课程设计(银行家算法的模拟实现)

操作系统课程设计(银行家算法的模拟实现)

操作系统课程设计(银行家算法的模拟实现)1、银行家算法中的数据结构(1)、可利用资源向量Available,这是一个含有m个元素的数组,其中的每个元素代表一类可利用资源的数目,其初始值是系统中所配置的该类全部资源的数目,其数值随该类资源的分配和回收而动态改变。

如果Available[j]=K,则表示系统中现有Rj类资源K个。

(2)、最大需求矩阵Max,这是一个n*m的矩阵,它定义了系统中n个进程中的每一个进程对m类资源的最大需求。

如果Max[i,j]=K,则表示进程i需要Rj类资源的最大数目为K。

(3)、分配矩阵Allocation。

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

如果Allocation[i,j]=K,则表示进程i当前已经分得Rj类资源的数目为K。

(4)、需求矩阵Need。

这也是一个n*m的矩阵,用以表示每个进程尚需要的各类资源数。

如果Need[i,j]=K,则表示进程i还需要Rj类资源K个,方能完成其任务。

上述三个矩阵间存在以下关系:Need[i,j]=Max[i,j]-Allocation[i,j]2、银行家算法应用模拟实现Dijkstra的银行家算法以避免死锁的出现,分两部分组成:一是银行家算法(扫描);二是安全性算法。

(1)银行家算法(扫描)设Requesti是进程Pi的请求向量,如果Requesti[j]=K,表示进程Pi需要K个Ri类型的资源。

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

②如果Requesti[j]<=Allocation[i,j],便转向步骤③;否则表示尚无足够资源,Pi需等待。

③系统试探着把资源分配给进程Pi,并修改下面数据结构中的数值。

Available[j]=Available-Requesti[j];Allocation[i,j]=Allocation[i,j]+Requesti[j];Need[i,j]=Need[i,j]-Requesti[j];④系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。

银行家算法(操作系统)

银行家算法(操作系统)

银行家算法(操作系统)银行家算法(操作系统)一、概述银行家算法是一种用于避免进程死锁的资源分配算法。

在多进程并发执行的系统中,进程需要申请和释放资源,而银行家算法可以通过判断资源申请是否会导致系统陷入死锁状态,从而保证系统的安全性和可靠性。

二、系统资源1. 资源类型系统中的资源可以分为不同类型,比如A、B、C等。

每种资源类型都有固定的数量,例如A类型资源有10个。

不同资源类型之间是独立的,即没有关联性。

2. 可用资源在系统中,每种资源类型都有一定数量的可用资源。

初始情况下,可用资源数目应该与系统中实际可用资源数目相对应。

3. 进程资源申请和释放进程可以通过申请资源来执行运算或操作。

如果系统能够满足进程的资源需求,则满足其资源请求,否则,该进程必须等待直到所需资源变得可用。

当进程完成了对资源的操作后,必须释放这些资源,以便其他进程可以使用。

三、银行家算法原理1. 数据结构银行家算法通过维护以下数据结构来判断系统是否处于安全状态:- Avlable: 一维数组,表示每种资源类型的可用数量。

- Max: 二维数组,表示每个进程对每种资源类型的最大需求量。

- Allocation: 二维数组,表示每个进程已经分配到的资源数量。

- Need: 二维数组,表示每个进程还需要的资源数量。

2. 安全状态系统处于安全状态的条件是:存在一个安全序列,使得该序列中每个进程的资源需求能够被满足。

3. 安全检查银行家算法通过进行安全检查来判断系统是否处于安全状态。

检查过程包括以下步骤:- 初始化Work为Avlable。

- 找到一个进程i,使得Need[i] <= Work。

如果这样的进程不存在,则转到步骤5。

- 分配资源给进程i。

- 执行资源分配后的安全性检查,即临时修改Work和Allocation。

- 如果系统处于安全状态,则转到步骤2;否则,继续进行步骤5。

- 如果所有进程都获得了所需的资源,则系统处于安全状态;否则,系统处于不安全状态。

编程序模拟银行家算法1

编程序模拟银行家算法1

武汉理工大学华夏学院课程设计报告书课程名称:操作系统原理题目:编程序模拟银行家算法系名:信息工程系专业班级:计算机1111班姓名:学号: 10210411131 指导教师:苏永红2013 年 6 月 28 日课程设计任务书学生姓名:专业班级:计算机1111班指导教师:苏永红工作单位:信息工程系设计题目:编程序模拟银行家算法初始条件:Linux操作系统,GCC编译环境要求完成的主要任务:主要任务:银行家算法是避免死锁的一种重要方法,本实验要求用用c/c++语言在Linux操作系统环境下编写和调试一个简单的银行家算法程序。

加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。

思想:将一定数量的资金供多个用户周转使用,当用户对资金的最大申请量不超过现存资金时可接纳一个新客户,客户可以分期借款,但借款总数不能超过最大的申请量。

银行家对客户的借款可以推迟支付,但是能够使客户在有限的时间内得到借款,客户得到所有的借款后能在有限的时间内归还。

用银行家算法分配资源时,测试进程对资源的最大需求量,若现存资源能满足最大需求就满足当前进程的申请,否则推迟分配,这样能够保证至少有一个进程可以得到所需的全部资源而执行到结束,然后归还资源,若OS能保证所有进程在有限的时间内得到所需资源则称系统处于安全状态。

设计报告撰写格式要求:1设计题目与要求 2 设计思想3系统结构 4 数据结构的说明和模块的算法流程图5 使用说明书(即用户手册):内容包含如何登录、退出、读、写等操作说明6 运行结果和结果分析(其中包括实验的检查结果、程序的运行情况)7 自我评价与总结 8 附录:程序清单,注意加注释(包括关键字、方法、变量等),在每个模块前加注释;时间安排6月24日布置课程设计任务;分配题目后,查阅资料、准备程序;6月 25~6月27 日上机调试程序、书写课程设计报告;6月28 日提交课程设计报告及相关文档。

指导教师签字:2013年6月28日系主任签字:2013年6月28日目录1设计题目与要求 (4)1.1设计题目 (4)1.2要求完成的任务 (4)1.3主要任务 (4)1.4提示 (4)2设计思路 (5)2.1算法思路 (5)2.2银行家算法 (5)3系统结构 (5)3.1主要用到的数据结构 (5)3.2程序模块 (5)3.3各模块间的调用关系 (6)4数据结构的说明和模块的算法流程图 (6)4.1数据结构说明 (6)4.1算法流程图 (7)5使用说明 (9)6测试结果截图 (10)6.1开始界面 (10)6.2输出界面 (10)7自我评价与总结 (14)8参考文献 (15)9附录:程序清单 (16)1设计题目与要求1.1设计题目编程序模拟银行家算法1.2要求完成的任务银行家算法是避免死锁的一种重要方法,本实验要求用用c/c++语言在Linux操作系统环境下编写和调试一个简单的银行家算法程序。

银行家算法模拟实验

银行家算法模拟实验

银行家算法模拟实验(总12页)--本页仅作为文档封面,使用时请直接删除即可----内页可以根据需求调整合适字体及大小--淮海工学院计算机工程学院实验报告书课程名:《操作系统》题目:银行家算法模拟实验班级: Gy计算机121学号: 61姓名:张凯一、实验目的与要求1.目的:用C、C++或Java语言编写一个简单的银行家算法模拟程序,用银行家算法实现资源分配。

本实验可加深对行家算法的理解。

2.要求:设计五个进程{P0,P1,P2,P3,P4}共享三类资源{A,B,C}的系统,{A,B,C}的资源数量分别为10,5,7。

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

要求程序具有显示和打印各进程的某一时刻的资源分配表和安全序列;显示和打印各进程依次要求申请的资源号以及为某进程分配资源后的有关资源数据的情况。

二、程序流程图三、主要程序清单#include <>#include <>#include <>#include <iomanip>#define n 10#define true 1#define false 0int N ; // 资源总类int M; //总进程数int Available[50];int Max[50][50];int Allocation[50][50]={0};int Need[50][50]={0};int Work[50]={0};int Temp[50]={0}; //存放安全序列号char Name[50]={0};int Sum[50]={0};int Request[50]={0};void Print(){int k=0;cout<<" ***********资源分配表***********"<<endl;cout<<" Process "<<" Max "<<" Allocation "<<" Need "<<" Available"<<endl;cout<<" A B C "<<" A B C "<<" A B C "<<" A B C"<<endl;for(int i=0;i<M;i++){cout<<" P"<<i<<" ";for(int 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<<" ";for(j=0;j<N;j++){ if(k!=3){cout<<" "<<Available[j];k++;}}cout<<endl;}}void Create(){int i,j;cout<<"请输入您要创建进程的数量:"<<endl;cin>>M;cout<<"请输入各类资源的总数:("<<N<<"个)"<<endl;for(i=0;i<N;i++)cin>>Sum[i];k1: cout<<endl;cout<<"请输入各类进程所需要资源最大数目:("<<N*M<<"个)"<<endl;for(i=0;i<M;i++)for( j=0;j<N;j++){cin>>Max[i][j];if(Max[i][j]>Sum[j]){cout<<"占有资源超过了声明的该资源总数,请重新输入!"<<endl;goto k1;}}k2: cout<<endl;cout<<"请输入各类进程已分配的各类资源的数目:("<<N*M<<"个)"<<endl;for(i=0;i<M;i++)for(j=0;j<N;j++){cin>>Allocation[i][j];if(Allocation[i][j]>Max[i][j]){cout<<"占有资源超过了声明的该资源总数,请重新输入!"<<endl;goto k2;}}int p;for(i=0;i<N;i++){ p=Sum[i];for(j=0;j<M;j++)p=p-Allocation[j][i];Available[i]=p;}for(i=0;i<M;i++)for(j=0;j<N;j++)Need[i][j]=Max[i][j]-Allocation[i][j]; }void restore(int i){int j;for(j=0;j<N;j++){Available[j]+=Request[j];Allocation[i][j]-=Request[j];Need[i][j]+=Request[j];}}int changedata(int i){int j;for(j=0;j<N;j++){Available[j]+=Request[j];Allocation[i][j]-=Request[j];Need[i][j]+=Request[j];}return 1;}int Safe() //处理传过来的第几个进程{int i=0;int k=0;int m;int apply,Finish[50]={0};int j,flag=0;for(i=0;i<N;i++)Work[i]=Available[i];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;flag;}}}}for(i=0;i<M;i++){if(Finish[i]==false){cout<<"系统不安全!!! 本次资源申请不成功!!!"<<endl;return -1;}}cout<<"经安全性检查,系统安全,本次分配成功!!"<<endl;cout<<"安全序列号 ";for(i=0;i<M-1;i++)cout<<"P"<<Temp[i]<<", ";cout<<"P"<<Temp[i]<<">"<<endl;cout<<endl;return 0;}void dijkstra(){char ch;int i=0,j=0;ch='y';cout<<"请输入你要请求的资源进程号(0-"<<M-1<<"):"<<endl;cin>>i;cout<<"请输入进程"<<i<<"请求Request变量"<<endl;for(i=0;i<N;i++){cout<<Name[j]<<":";cin>>Request[i];}for(i=0;i<N;i++){if(Request[i]>Need[j][i]){cout<<"进程"<<i<<"申请的资源大于他需要的资源";cout<<"分配不合理,不予分配!"<<endl;ch='n';break;}elseif(Request[j]>Available[j]){cout<<"进程"<<i<<"申请的资源大于系统可利用的资源";cout<<"分配出错,不予分配!"<<endl;ch='n';break;}if(ch='y')changedata(i);Print();Safe();if(Safe()==1)restore(i);}}int main(){int c;Create();Print();Safe();while(c){cout<<" 银行家算法"<<endl;cout<<" 1 分配资源"<<endl;cout<<" 2 离开 "<<endl;cout<<"请选择功能号:"<<endl;cin>>c;switch(c){case 1:dijkstra();break;case 0:c=0;break;default:cout<<"请正确选择功能号(0--1)"<<endl;break;}}return 1;}四、程序运行结果五、实验体会通过这次实验,我学会了银行家算法有原理,并用自己已学的知识,结合书本完成了此次实验,收获蛮大。

银行家算法的模拟实现实验报告

银行家算法的模拟实现实验报告

银行家算法的模拟实现一、实验题目:模拟实现银行家算法的处理过程二、实验目的:银行家算法是避免死锁的代表性算法。

本实习旨在加深了解有关资源申请、避免死锁、状态安全性等概念,并体会和运用避免死锁的具体实施方法。

然后依照本实习,自行设计模拟程序。

三、实验原理:1.我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。

操作系统按照银行家制定的规则为进程分配资源。

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

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

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

2. 安全状态:如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态。

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

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

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

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

3. 设requesti为进程p[i]的请求向量,如果requesti[j]=K,表示进程p[i]需要K个Rj资源。

当系统发出请求后,系统按下述步骤开始检查:1)如果requesti[j]<=need[i][j],转向步骤2;否则报告出错,申请的资源已经大于它需要的最大值。

2)如果requesti[j]<=available[j],转向步骤3;否则报告出错,尚无足够的资源。

3)系统试探着把资源分配给p[i],并修改下列数据结构中的值:available[j]=available[j]-request[j]allocation[i][j]=allocation[i][j]+request[j]need[i][j]=need[i][j]-request[j]4)系统进行安全性算法,检查此次分配后,系统是否还处于安全状态,若安全,把资源分配给进程p[i];否则,恢复原来的资源分配状态,让进程p[i]等待。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
{
int while1 = 1;
cout<<" 银行家算法模拟实验 (1010321224)"<<endl;
init();
while(while1)
{
int in;
cout<<" 进程信息加载完毕,输入数字选择功能:"<<endl;
for( i = 0 ; i < resourceNumber ; i++ )
{
cin>>get[n - 1][i] ;
}
}
void run() ///运行银行家算法
{
int num;
do
{
num = check();
free(num);
if( num == -1 )
showeCourseMax(); //输出各个进程最大资源需求量
getInit(); //初始化各个进程已获得资源量
lastInit(); //对系统资源剩余量初始化
showeResource(); //输出剩余系统资源
}
void main()
{
cout<<"各个进程的各种资源最大总数分别是:"<<endl;
cout<<'\t';
for (int i = 0 ; i < resourceNumber ; i++ )
{
cout<<"资源"<<i+1<<'\t';
}
cout<<endl;
for( i = 0 ; i < courseNumber ; i++ )
{
for(int i = 0 ; i < courseNumber ; i++ )
{
courseFlag[i] = false;
}
}
void lastInit() //对系统资源剩余量初始化
{
for(int i = 0 ; i < resourceNumber ; i++)
{
resourceLast[i] = resourceMax[i] ;
}
for( i = 0 ; i < resourceNumber ; i++ )
{
for( int j = 0 ; j < courseNumber ; j++)
{
resourceLast[i] -= get[j][i];
#include<iostream>
#include<string.h>
#include<stdio.h>
using namespace std;
int resourceMax[20]; // 系统最大资源量
int resourceLast[20] = {0}; //系统剩余资源量
okNum++;
for( int j = 0 ; j < resourceNumber ; j++ )
{
resourceLast[j] += get[i -1][j];
}
}
}
void addCourse() //添加一个进程
{
courseFlag[courseNumber] = false ;
int list[100]; //存储满足条件的进程的信息
int okNum = 0; //存储满足的进程个数,最大值为进程个数,如为最大值则进程组安全
void flagInit() //对 courseFlag[100]初始化
}
}
}
void resourceInit() //系统资源初始化
{
cout<<"请输入系统资源的种类数量(1~20): ";
cin>>resourceNumber;
cout<<"请依次输入各种资源的数量: ";
for(int i = 0 ; i < resourceNumber ; i++ )
{
cout<<"各个进程的各种资源已获得量分别是:"<<endl;
cout<<'\t';
for (int i = 0 ; i < resourceNumber ; i++ )
{
cout<<"资源"<<i+1<<'\t';
}
cout<<endl;
for( i = 0 ; i < courseNumber ; i++ )
{
cout<<"请依次输入各进程已获得各种资源的数量(用( " << courseNumber <<" * " << resourceNumber<<" )矩阵表示,无则为0): "<<endl;
for(int i = 0 ; i < courseNumber ; i++ )
{
for(int j = 0 ;j < resourceNumber ; j++ )
{
for(int i = 0 ; i < courseNumber ; i++)
{
if ( courseFlag[i] == false )
{
for( int j = 0 ; j < resourceNumber ; j++ )
{
if(needMax[i][j] - get[i][j] > resourceLast[j])
{
cin>>resourceMax[i];
}
}
void courseInit() //初始化各个进程最大资源需求量
{
cout<<"请输入系统中进程的数量(1~100): ";
cin>>courseNumber;
cout<<"请依次输入各进程各种资源的最大数量(用( " << courseNumber <<" * " << resourceNumber<<" )矩阵表示): "<<endl;
{
cin>>get[i][j];
} } } void showeResource() //输出剩余系统资源
{
cout<<"系统各个资源剩余数分别是:"<<endl;
for (int i = 0 ; i < resourceNumber ; i++ )
{
cout<<"资源"<<i+1<<'\t';
}
cout<<"\n\n"<<endl;
}
else
if (okNum == 0)
cout<<"该进程组不安全!!\n\n"<<endl;
cout<<endl;
}
void init()
{
resourceInit(); //系统资源初始化
courseInit(); //初始化各个进程最大资源需求量
for( i = 0 ; i < resourceNumber ; i++ )
{
cin>>get[courseNumber ][i] ;
}
courseNumber++;
}
void alterCourse() //修改一个进程
{
int n;
cout<<"请依次输入需要修改进程的序号: ";
{
cout<<"进程"<<i+1<<'\t';
for(int j = 0 ;j < resourceNumber ; j++ )
{
cout<<needMax[i][j]<<'\t';
}
cout<<endl;
}
cout<<"\n"<<endl;
}
void showeCourse() //输出各个进程已获得资源量
{
cout<<"该进程组安全"<<","<<"其先后顺序如下:"<<endl;
for(int i = 0 ; i < okNum ; i++)
相关文档
最新文档