银行家算法实验报告(C语言版)
银行家算法实验报告

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

淮海工学院计算机工程学院实验报告书课程名:《操作系统原理》题目:银行家算法班级:学号:姓名:一、实验目的银行家算法是操作系统中避免死锁的典型算法,本实验可以加深对银行家算法的步骤和相关数据结构用法的更好理解。
实验环境Turbo C 2.0/3.0或VC++6.0实验学时4学时,必做实验。
二、实验内容用C语言编写一个简单的银行家算法模拟程序,用银行家算法实现资源分配。
程序能模拟多个进程共享多种资源的情形。
进程可动态地申请资源,系统按各进程的申请动态地分配资源。
要求程序具有显示和打印各进程的某一时刻的资源分配表和安全序列;显示和打印各进程依次要求申请的资源数量以及为某进程分配资源后的有关资源数据的情况。
三、实验说明实验中进程的数量、资源的种类以及每种资源的总量Total[j]最好允许动态指定。
初始时每个进程运行过程中的最大资源需求量Max[i,j]和系统已分配给该进程的资源量Allocation[i,j]均为已知(这些数值可以在程序运行时动态输入),而算法中其他数据结构的值(包括Need[i,j]、Available[j])则需要由程序根据已知量的值计算产生。
四、实验步骤1、理解本实验中关于两种调度算法的说明。
2、根据调度算法的说明,画出相应的程序流程图。
3、按照程序流程图,用C语言编程并实现。
五、分析与思考1.要找出某一状态下所有可能的安全序列,程序该如何实现?答:要找出这个状态下的所有可能的安全序列,前提是要是使这个系统先处于安全状态,而系统的状态可通过以下来描述:进程剩余申请数=最大申请数-占有数;可分配资源数=总数-占有数之和;通过这个描述来算出系统是否安全,从而找出所有的安全序列。
2.银行家算法的局限性有哪些?答:银行家算法是一种最有代表性的避免死锁的算法。
银行家算法即把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。
操作系统课程设计实验报告用C实现银行家算法

操作系统实验报告(2)学院:计算机科学与技术学院班级:计091学号:姓名:时间:2011/12/30目录1.实验名称 (3)2.实验目的 (3)3.实验内容 (3)4.实验要求 (3)5.实验原理 (3)6.实验环境 (4)7.实验设计 (4)7.1数据结构设计 (4)7.2算法设计 (6)7.3功能模块设计 (7)8.实验运行结果 (8)9.实验心得 (9)附录:源代码(部分) (9)一、实验名称:用C++实现银行家算法二、实验目的:通过自己编程来实现银行家算法,进一步理解银行家算法的概念及含义,提高对银行家算法的认识,同时提高自己的动手实践能力。
各种死锁防止方法能够阻止发生死锁,但必然会降低系统的并发性并导致低效的资源利用率。
死锁避免却与此相反,通过合适的资源分配算法确保不会出现进程循环等待链,从而避免死锁。
本实验旨在了解死锁产生的条件和原因,并采用银行家算法有效地防止死锁的发生。
三、实验内容:利用C++,实现银行家算法四、实验要求:1.完成银行家算法的设计2.设计有n个进程共享m个系统资源的系统,进程可动态的申请和释放资源,系统按各进程的申请动态的分配资源。
五、实验原理:系统中的所有进程放入进程集合,在安全状态下系统收到进程的资源请求后,先把资源试探性的分配给它。
之后,系统将剩下的可用资源和进程集合中的其他进程还需要的资源数作比较,找出剩余资源能够满足的最大需求量的进程,从而保证进程运行完毕并归还全部资源。
这时,把这个进程从进程集合中删除,归还其所占用的所有资源,系统的剩余资源则更多,反复执行上述步骤。
最后,检查进程集合,若为空则表明本次申请可行,系统处于安全状态,可以真正执行本次分配,否则,本次资源分配暂不实施,让申请资源的进程等待。
银行家算法是一种最有代表性的避免死锁的算法。
在避免死锁方法中允许进程动态地申请资源,但系统在进行资源分配之前,应先计算此次分配资源的安全性,若分配不会导致系统进入不安全状态,则分配,否则等待。
操作系统实验报告--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、检测系统资源分配是否安全结果。
银行家算法操作系统实验报告

竭诚为您提供优质文档/双击可除银行家算法操作系统实验报告篇一:计算机操作系统银行家算法实验报告计算机操作系统实验报告一、实验名称:银行家算法二、实验目的:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计: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 如找到,执行步骤(3);否则,执行步骤(4)。
(3)当进程p获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:work=work+Allocation;Finish[i]=true;转向步骤(2)。
操作系统课程设计实验报告用C实现银行家算法

操作系统实验报告2学院:计算机科学与技术学院班级:计091学号:姓名:时间:2011/12/30目录1.实验名称 (3)2.实验目的 (3)3.实验内容 (3)4.实验要求 (3)5.实验原理 (3)6.实验环境 (4)7.实验设计 (4)数据结构设计 (4)算法设计 (6)功能模块设计 (7)8.实验运行结果 (8)9.实验心得 (9)附录:源代码部分 (9)一、实验名称:用C++实现银行家算法二、实验目的:通过自己编程来实现银行家算法,进一步理解银行家算法的概念及含义,提高对银行家算法的认识,同时提高自己的动手实践能力;各种死锁防止方法能够阻止发生死锁,但必然会降低系统的并发性并导致低效的资源利用率;死锁避免却与此相反,通过合适的资源分配算法确保不会出现进程循环等待链,从而避免死锁;本实验旨在了解死锁产生的条件和原因,并采用银行家算法有效地防止死锁的发生;三、实验内容:利用C++,实现银行家算法四、实验要求:1.完成银行家算法的设计2.设计有n个进程共享m个系统资源的系统,进程可动态的申请和释放资源,系统按各进程的申请动态的分配资源;五、实验原理:系统中的所有进程放入进程集合,在安全状态下系统收到进程的资源请求后,先把资源试探性的分配给它;之后,系统将剩下的可用资源和进程集合中的其他进程还需要的资源数作比较,找出剩余资源能够满足的最大需求量的进程,从而保证进程运行完毕并归还全部资源;这时,把这个进程从进程集合中删除,归还其所占用的所有资源,系统的剩余资源则更多,反复执行上述步骤;最后,检查进程集合,若为空则表明本次申请可行,系统处于安全状态,可以真正执行本次分配,否则,本次资源分配暂不实施,让申请资源的进程等待;银行家算法是一种最有代表性的避免的算法;在避免死锁方法中允许进程动态地申请资源,但系统在进行资源分配之前,应先计算此次分配资源的安全性,若分配不会导致系统进入不安全状态,则分配,否则等待;为实现银行家算法,系统必须设置若干;要解释银行家算法,必须先解释操作系统安全状态和不安全状态;安全序列是指一个进程序列{P1,…,Pn}是安全的,如果对于每一个进程Pi1≤i≤n,它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj j < i 当前占有资源量之和;安全状态:如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态;安全状态一定是没有死锁发生;不安全状态:不存在一个安全序列;不安全状态不一定导致死锁;我们可以把看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款;为保证资金的安全,银行家规定:1 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;2 顾客可以分期贷款,但贷款的总数不能超过最大需求量;3 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;4 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金.操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配;当进程在执行中继续申请资源时,先测试该进程本次申请的资源数是否超过了该资源所剩余的总量;若超过则拒绝分配资源,若能满足则按当前的申请量分配资源,否则也要推迟分配;六、实验环境:Win-7系统Visual C++七、实验设计:1.数据结构设计定义结构体:struct Process0, 0, 0;}}};class DataInit法设计class FindSafeListdb->available; db->pdb->ruleri.currentAvail db->pdb->ruleri-1.currentAvail;db->pdb->ruleri-1.allocation;db->pdb->ruleri.currentAvail{ return false; }db->sum{ return false; }}return true; laim_allocation{ return 1; }Source sdb->pi.allocation; db->ask;db->pi.db->ask;ifexsitSafeListdb db->ask;db->pi.db->ask;return 2;}db->0,0,0; 能模块设计class Data0, 0, 0;}}};class DataInitr1,r2,r3;cout<<'p'<<i<<" max allocationclaimR1,R2,R3: ";r1,r2,r3;r1=db->pi.>pi.;pi.;r3=db->pi.>pi.;db->pi.r1, r2, r3;}}};class Displaylaim;cout<<"\t\t";displaySourcepi.allocation;cout<<endl;}cout<<endl;}void displaySafeListData db urrentAvail;cout<<" ";displaySourcedb->pdb->ruleri.claim;cout<<" ";displaySourcedb->pdb->ruleri.allocation;cout<<" ";displaySourcedb->pdb->ruleri.claim_allocation;cout<<" true";cout<<endl;}}void displayAskResultData db,int n db->available;db->pdb->ruleri.currentAvail db->pdb->ruleri-1.currentAvail;db->pdb->ruleri-1.allocation;db->pdb->ruleri.currentAvail{ return false; }db->sum{ return false; }}return true; laim_allocation{ return 1; }Source sdb->pi.allocation; db->ask;db->pi.db->ask;ifexsitSafeListdb db->ask;db->pi.db->ask;return 2;}db->0,0,0; //找到安全序列,将请求资源置零,返回3return 3;}};void main{Data db;db=new Data;ifdb{ cout<<"errorno enough memory space"; return; } DataInit dataInit;db; //设置进程个数db; //设置系统总资源量db; //设置当前系统可获得资源量db; //设置t0时刻进程基本状态Display display;FindSafeList findSafeList;int r1=0,r2=0,r3=0;int c;db->r1,r2,r3; //设置请求资源为0,即无请求c=db,0; //寻找安全序列,返回结果ifc=3{ cout<<"t0时刻的进程组不存在安全序列\n"; return; }int choice=1;int pi;whilechoice{cout<<"\n 选择操作:\n 1 查看进程情况\n 2 请求分配资源\n 0 退出\n ";cin>>choice;switchchoice{case 1:{cout<<"当前资源量availableR1,R2,R3:\n ";db->available;cout<<endl;cout<<"\n当前进程资源分配情况piR1,R2,R3: \n";cout<<" 进程\tclaim\t\tallocation\n";db->p,db->pLength;break;}case 2:{cout<<"输入请求资源进程序号:";cin>>pi;cout<<"输入请求资源R1,R2,R3: 0,0,0表示当前进程组无请求\n";cin>>r1>>r2>>r3;db->r1,r2,r3;c=db,pi;db,c;cout<<endl;break;}case 0:{ break; }default:{ cout<<"input errortry again\n"; break; }}}}。
银行家算法实验报告

操作系统实验报告——银行家算法计科101班张昊翔1007300204一.实验目的1. 加深对死锁概念的理解。
2. 能够利用银行家算法,有效避免死锁的发生,或检测死锁的存在。
二.主要思想我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。
当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量,若能满足则按当前的申请量分配资源,否则也要推迟分配。
三.实验原理在多道程序系统中,虽可借助于多个进程的并发执行,来改善系统的资源利用率,提高系统的吞吐量,但可能发生一种危险——死锁。
所谓死锁,是指多个进程在运行过程中因争夺资源而造成的一种僵局,当进程处于这种僵局状态时,若无外力作用,它们都将无法再向前推进。
为保证系统中诸进程的正常运行,应事先采取必要的措施,来预防死锁。
最有代表性的避免死锁的方法,是Dijkstra的银行家算法。
银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
死锁的产生,必须同时满足四个条件,第一个为互斥条件,即一个资源每次只能由一个进程占用;第二个为请求和保持条件,指进程已经保持了至少一个资源,但又提出了新的资源请求,而该资源又被其他进程占有,此时请求进程阻塞,但又对自己已获得的其他资源保持不放;第三个为非剥夺条件,即在出现死锁的系统中一定有不可剥夺使用的资源;第四个为循环等待条件,系统中存在若干个循环等待的进程,即其中每一个进程分别等待它前一个进程所持有的资源。
银行家算法实验报告

银行家算法实验报告 Company number:【0089WT-8898YT-W8CCB-BUUT-202108】计算机操作系统实验报告一、实验名称:银行家算法二、实验目的:银行家算法是避免死锁的一种重要方法,通过编写一个简单的银行家算法程序,加深了解有关资源申请、避免死锁等概念,并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计: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、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
}
for(i=0;i<n;i++){
available[i]=available[i]-request[number][i];
allocation[number][i]=allocation[number][i]+request[number][i];
need[number][i]=need[number][i]-request[number][i];
(1)设置两个向量:工作向量Work,它表示系统可提供给进程继续运行所需的各类资源数目,在执行安全性算法开始时,Work= Available。工作向量Finish,它表示系统是否有足够的资源分配给进程,使之运行完成。开始时先做Finish[i]=false;当有足够的资源分配给进程时,再令Finish[i]=true。
}
printf("请输入分配矩阵:\n");
for (i=0;i<m;i++)
for (j=0;j<n;j++)
{
scanf("%d",&allocation[i][j]);
}
for (i=0;i<m;i++)
for (j=0;j<n;j++)
{
need[i][j]=max[i][j]-allocation[i][j];
(4)如果所有的Finish[i]=true都满足,则表示系统处于安全状态,否则,处于不安全状态。
四、实验结果及分析
1.实验设计说明
按0由用户输入,按1由系统提供数据
2.实验代码
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define max_process 50 //最大进程数
int finish[max_process];
int m=5,n=3;
void init();
int safe();
void bank();
void init2();
void print();
void print2();
void main()
{
int i;
printf("请输入测试数据,按0由用户输入测试数据,按1由系统提供测试数据:\n");
printf(" Ture\n");
for(p=0;p<n;p++)
work[p]=work[p]+allocation[l[i]][p];
if(i==4) return true;
}
}
else {printf("系统不安全\n"); return false;}
}
void bank(){
int i,number;
(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];
《操作系统》课程综合性实验报告
姓名:学号:2016年11月20日
实验题目
进程调度算法程序设计
一、实验目的
通过对安全性算法和银行家算法的模拟,进一步理解资源分配的基本概念,加深对资源申请,资源分配(银行家算法)以及系统是否能分配(安全性算法)资源的理解。
二、设备与环境
1.硬件设备:PC机一台
2.软件环境:安装Windows操作系统或者Linux操作系统,并安装相关的程序开发环境,如C \C++\Java等编程语言环境。
(4)试分配后,执行安全性检查,调用check()函数检查此次资源分配后系统是否处于安全状态。若安全,才正式将资源分配给进程。否则本次试探分配作废,恢复原来的资源分配状态,让该进程等待。
(5)用do{…}while循环语句实现输入字符y/n判断是否继续进行资源申请。
(二)安全性算法(safe()函数):
for(i=0;i<m;i++)
{ printf("p%d\t",i);
for(j=0;j<n;j++)
{
printf("%d\t",allocation[i][j]);
}
printf("\n");
}
printf("需求矩阵如下:\n");
for(i=0;i<m;i++)
{ printf("p%d\t",i);
for (i=0;i<n;i++) work[i]=available[i];
for(i=0;i<m;i++)
{
printf(" p%d |",l[i]);
for(p=0;p<n;p++)
printf("%3d ",work[p]);
printf("|");
for(p=0;p<n;p++)
{
printf("%3d ",need[l[i]][p]);
for(j=0;j<n;j++)
{
printf("%d\t",need[i][j]);
}
printf("\n");
}
printf("系统可提供资源如下:\n");
for(j=0;j<n;j++)
printf("%d\t",available[j]);
printf("\n");
}
int safe()
{
char answer;
while(1){
printf("\n请输入需申请资源的进程号(第一个进程号为0):\n");
scanf("%d",&number);
printf("请依次输入该进程所需申请的所有资源数目:\n");
for(i=0;i<n;i++)
scanf("%d",&request[number][i]);
scanf("%d",&n);
printf("请按顺序输入系统中可利用的每种资源量:\n");
for(i=0;i<n;i++)
scanf("%d",&available[i]);
printf("请输入最大需求矩阵:\n");
for (i=0;i<m;i++)
for (j=0;j<n;j++)
{
scanf("%d",&max[i][j]);
int i,j,k=0,l[m],p;
int work[n];
for (i=0;i<n;i++)
work[i]=available[i];
for (i=0;i<m;i++)
finish[i]=false;
for(i=0;i<m;i++)
{
if(finish[i]==true) continue;
else{
}
}
if(k==m)
{
printf("\n");
printf("**************************此时刻资源分配情况**************************\n");
printf("进程| Work | Need | Allo | W+Allo | Finish\n");
}
printf("|");
for(p=0;p<n;p++)
{
printf("%3d ",allocation[l[i]][p]);
}
printf("|");
for(p=0;p<n;p++)
{
printf("%3d ",allocation[l[i]][p]+work[p]);
}
printf("|");
for(i=0;i<n;i++) {
if(request[number][i]>need[number][i])
{
printf("申请的资源超过还需要的资源,请重新输入\n");
continue;
}
if(request[number][i]>available[i])
{
printf("申请的资源超过所能提供的资源,请重新输入\n");
scanf("%d",&i);
switch(i){
case 0: init();
break;
case 1: init2();
break;
}
print();