操作系统课程设计实验报告用C++实现银行家算法
计算机操作系统课程设计报告《Linux下C编程实现银行家算法》
《计算机操作系统》课程设计题目:Linux下C编程实现银行家算法专业:软件工程年级:小组成员:指导教师:时间:地点:2014年12 月摘要Dijkstra(艾兹格·迪科斯彻) 的银行家算法是最有代表性的避免死锁的算法,该算法由于能用于银行系统现金贷款的发放而得名。
银行家算法是在确保当前系统安全的前提下推进的。
对进程请求先进行安全性检查,来决定资源分配与否,从而确保系统的安全,有效的避免了死锁的发生。
该论文在理解和分析了银行家算法的核心思想以及状态的本质涵义的前提下,对算法的实现在总体上进行了设计,包括在对算法分模块设计,并对各个模块的算法思想通过流程图表示,分块编写代码,并进行测试,最后进行程序的测试,在设计思路上严格按照软件工程的思想执行,确保了设计和实现的可行,可信。
代码实现采用C语言。
目录目录1.概述 (4)2.课程设计任务及要求 (4)2.1 设计任务 (4)2.2设计要求 (5)3.算法及数据结构 (5)3.1算法的总体思想 (5)3.2 安全算法模块 (6)3.2.3 算法(流程图表示,或伪C表示) (7)4. 程序设计与实现 (9)4.1程序流程图 (9)4.2程序代码(部分代码) (9)4.3实验结果 (11)5 结论 (13)6 收获、体会和建议。
(14)7 参考文献。
(14)1.概述银行家算法是一种最有代表性的避免死锁的算法。
在避免死锁方法中允许进程动态地申请资源,但系统在进行资源分配之前,应先计算此次分配资源的安全性,若分配不会导致系统进入不安全状态,则分配,否则等待。
为实现银行家算法,系统必须设置若干数据结构。
要解释银行家算法,必须先解释操作系统安全状态和不安全状态。
安全序列是指一个进程序列{P1,…,Pn}是安全的,即对于每一个进程Pi(1≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
安全状态如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态。
《操作系统》综合实训报告-银行家算法
题目四银行家算法一、实验目的1、通过银行家算法理解操作系统安全状态和不安全状态。
2、理解银行家算法的避免死锁的主要思想。
3、通过实验更加深入理解死锁、产生死锁的必要条件、安全状态等重要概念,并掌握避免死锁的具体实施方法。
二、实验要求及内容实验要求:1、根据教材在T0时刻系统分配的资源,用银行家算法判断系统是否处于安全序列,它的安全序列怎样。
2、理解银行家算法的思想,独立编写银行家算法,实现对进程请求的判断和安全性的检测,是否存在安全序列。
实验内容:1、在window平台中,利用visual c++6.0环境编写c语言,模拟一个动态资源分配的银行家算法程序。
2、通过手动输入初始资源分配列表的值,手动输入进程请求的请求信息(进程号和资源请求数),后对系统进行安全性判断,求出安全序列。
3、手动进行进程请求的模拟输入,并通过算法判断,进程请求的合理性和剩余资源对请求的满足性,来对请求选择进行分配。
后对其序列进行安全性检测,如系统处于不安全状态,则对其进行恢复。
二、主要思想1、算法思路操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。
当进程在执行中继续申请资源时,先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量,若能满足则按当前的申请量分配资源,否则也要推迟分配。
2、银行家算法和安全性检查算法原理银行家算法:银行家算法最初级原为银行系统设计,以确保银行在发放现金贷款时,不会发生不能满足所有客户需要的情况。
在OS设计中,也可以用它来避免死锁。
为实现银行家算法,每个新进程在进入系统时它必须申明在运行过程中,可能需要的每种资源类型的最大单元数目,其数目不应超过系统所拥有的资源总量。
C语言实验报告范例
C语言实验报告范例
实验题目:C语言实现银行家算法
实验目的:掌握C语言实现银行家算法的基本思想,并能熟练应用矩阵处理实现银行
家算法的功能。
实验内容:
1. 利用C语言实现银行家算法的核心思想,利用矩阵处理实现其核心功能模块。
2. 银行家算法是一种负责实现“当前分配”的基于矩阵的编程模型。
该算法可以通
过利用安全状态来识别一次可行解,从而解决请求和分配资源的冲突问题。
3. 根据上述信息,我们设计了C语言实现银行家算法的基本框架,包括初始化步骤、可行性检查步骤、回滚步骤以及主步骤。
4. 在初始化步骤中,我们采用矩阵存储技术,将银行家算法中的各个参数保存起来,具体过程中采用数组存储。
5. 在可行性检查步骤中,我们判断当前系统状态是否处于安全状态,如果处于安全
状态,则继续完成下一步余额检查;否则,处理发生冲突时,回滚处理。
6. 在主步骤中,我们过程中判断若系统处于可行状态,则继续分配资源;否则,则
执行回滚操作,将系统恢复到上一状态。
实验结果和结论:
通过实验,我们学会了如何使用C语言来实现银行家算法,进而通过实现矩阵处理,
实现了该算法的核心功能模块。
此外,我们还学习了安全状态机制,进行系统可行性检查,和完成系统的分配工作,以达到有效地实现银行家算法的目的。
本次实验结论如下:
1. 通过C语言实现银行家算法中的核心功能模块,使系统的可行性检查得以有效实现;
2. 利用矩阵存储来实现系统的可行性检查,从而有效地节省时间和提高资源分配的
效率;
3. 通过回滚处理,有效地解决资源请求和分配冲突问题,使系统能够有效地实现安
全状态。
操作系统实验报告银行家算法
void change();当请求资源满足要求时,进行分配,系统资源发生改变;
int check();安全性算法,检查是否存在安全序列;
void outputsafe();输出安全序列的资源分配表。
4、检查代码,将编出的代码编译、链接,验证其正确性。
if (n==0)
printf("%6d%3d%3d\n",available[0],available[1],available[2]);
else
printf("\n");
}
line();
}
void change()//当Request[i,j]<=Available[j]时,系统把资源分配给进程P[i],Available[j]和Need[i,j]发生改变
line();
printf("资源情况Work Need Allocation Work+Allocation Finish\n");
printf("进程A B C A B C A B C A B C\n");
line();
for(n=0;n<5;n++)
printf("P%d%9d%3d%3d%5d%3d%3d%5d%3d%3d%6d%3d%3d%12s\n",safe[n],works[safe[n]][0],works[safe[n]][1],works[safe[n]][2],need[safe[n]][0],need[safe[n]][1],need[safe[n]][2],allocation[safe[n]][0],allocation[safe[n]][1],allocation[safe[n]][2],works[safe[n]][0]+allocation[safe[n]][0],works[safe[n]][1]+allocation[safe[n]][1],works[safe[n]][2]+allocation[safe[n]][2],finish[n]);
操作系统实验报告--银行家算法
操作系统实验报告二一:实验标题:实现死锁避免算法:银行家算法。
二:实验环境:操作系统:windows7编译器:Visual Studio 2010三:设计方案:1.实验目的通过程序模拟银行家算法,理解如何应用银行家算法避免死锁。
2.实验手段直接在C源程序定义整形进程数量、资源种类;用2维数组表示最大需求、已分配的资源。
从文件获取相关数量。
3.验证方式检验当前资源是否有安全序列,是的话输出安全序列。
四:实验代码:#include<stdio.h>#include<stdlib.h>#define P_num 5#define R_num 3int Allocation[P_num][R_num],Avaliable[R_num],Max[P_num][R_num]; int Need[P_num][R_num];int compare(int *a,int *b,int n){ int i;for(i = 0;i < n;i ++)if(a[i] < b[i])return 0;return 1;}void add(int *a,int *b,int n){ int i;for(i = 0;i < n;i++)a[i] += b[i];}void substract(int *a,int *b,int n){ int i;for(i = 0;i < n;i++)a[i] -= b[i];}void assign(int *a,int *b,int n){ int i;for(i = 0;i < n;i ++)a[i] = b[i];}void input(){FILE *fp;int i,j;if((fp = fopen("banker.txt","r")) == 0){ printf("cannot open the file");exit(0);}for(i = 0;i < P_num; ++i)for(j = 0;j < R_num; ++j){fscanf(fp,"%d",&Allocation[i][j]);}for(i = 0;i < P_num; ++i)for(j = 0;j < R_num; ++j){fscanf(fp,"%d",&Max[i][j]);}for(j = 0;j < R_num; ++j){fscanf(fp,"%d",&Avaliable[j]);}fclose(fp);for(i = 0;i < P_num; ++i)for(j = 0;j < R_num; ++j){Need[i][j] = Max[i][j] - Allocation[i][j];}}int issafe(int *sp){int i;int count = 0;int n = 0;int work[R_num],finish[P_num];assign(work,Avaliable,R_num);for(i = 0;i < P_num;i ++)finish[i] = 0;n = P_num;while(n --){for(i = 0;i < P_num;i ++)if((finish[i] == 0) && compare(work,Need[i],R_num)){ add(work,Allocation[i],R_num);finish[i] = 1;sp[count] = i;count ++;}if(count >= P_num)return 1;}return 0;}int request(int pid,int *r,int n){int i;int sp[P_num];if(compare(Need[pid],r,n) == 1 && compare(Avaliable,r,n) == 1){ substract(Avaliable,r,n);add(Allocation[pid],r,n);substract(Need[pid],r,n);if(issafe(sp)){printf("Security Path:\n\t");for(i = 0;i < P_num;i ++)printf("p[%d] ",sp[i]);printf("\n");return 1;}else{add(Avaliable,r,n);substract(Allocation[pid],r,n);add(Need[pid],r,n);printf("no Security Parh on this request\n");return 0;}}else{printf("no Security Parh on this request\n");return 0;}}void main(){int id,i;int r[R_num],sp[P_num];input();if(issafe(sp)){printf("Security Path:\n\t");for(i = 0;i < P_num;i ++)printf("p[%d] ",sp[i]);printf("\n");}elseprintf("failed\n");printf("input the new request's id:");scanf("%d",&id);printf("input the new request:");for(i = 0;i < R_num;++ i)scanf("%d",&r[i]);request(id,r,R_num);}banker.txt文件内容:0 1 02 0 03 0 22 1 10 0 27 5 33 2 29 0 22 2 24 3 33 3 2所得结果:Security Path:P[1] p[3] p[4] p[0] p[2] Intput the new request's id:0Input the new request:0 2 0Security Path:p[3] p[1] p[2] p[0] p[4] 问题和想法:。
操作系统银行家算法实验报告
实验五银行家算法一、实验目的和要求①理解死锁概念,银行家算法及安全检测算法。
②在Linux操作系统下用C++进行编程。
③利用C++设计实现银行家算法的基本过程。
④验证银行家算法对于避免死锁的作用。
二、实验方法内容①算法设计思路1.设计进程对各类资源最大申请表示及初值确定。
2.设定系统提供资源初始状况。
3.设定每次某个进程对各类资源的申请表示。
4.编制程序,依据银行家算法,决定其申请是否得到满足。
②算法流程图如下:③算法中用到的数据结构说明1. 可利用资源向量Available ,它是一个含有m个元素的数组,其中的每一个元素代表一类可利用的资源的数目,其初始值是系统中所配置的该类全部可用资源数目。
其数值随该类资源的分配和回收而动态地改变。
如果Available[j]=k,标是系统中现有Rj类资源k个。
2. 最大需求矩阵P,这是一个n×m的矩阵,它定义了系统中n个进程中的每一个进程对m类资源的最大需求。
如果P(i,j)=k,表示进程Pi需要Rj类资源的最大数目为k。
3. 分配矩阵Allocation,这是一个n×m的矩阵,它定义了系统中的每类资源当前一分配到每一个进程的资源数。
如果Allocation(i,j)=k,表示进程Pi 当前已经分到Rj类资源的数目为k。
Allocation i表示进程Pi的分配向量,有矩阵Allocation的第i行构成。
4. 需求矩阵Need,这是一个n×m的矩阵,用以表示每个进程还需要的各类资源的数目。
如果Need(i,j)=k,表示进程Pi还需要Rj类资源k个,才能完成其任务。
Need i表示进程i的需求向量,由矩阵Need的第i行构成。
上述三个矩阵间存在关系:Need(i,j)=P(i,j)-Allocation(i,j);5. Request i是进程Pi 的请求向量。
Request i(j)=k表示进程Pi请求分配Rj类资源k个。
操作系统课程设计实验报告用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; }}}}。
操作系统-银行家算法C语言实现
银行家算法C语言实现以下便是代码实现#include"stdio.h"#include"stdlib.h"#include"string.h"int n,m;struct info{int claim[50];int allocation[50];int need[50];}pro[50];int available[50];int request[50];void init(){ int i,j;printf("请输入资源种类数:");scanf("%d",&n);for(i=0;i<n;i++){ printf("请输入第%d个资源的最大资源数:\n",i);scanf("%d",&available[i]);}printf("请输入进程数:");scanf("%d",&m);printf("请输入各进程对各资源的最大需求数:\n");for(i=0;i<m;i++){ printf("请输入第%d进程对各资源的最大需求数:\n",i);for(j=0;j<n;j++){scanf("%d",&pro[i].claim[j]);pro[i].allocation[j]=0;pro[i].need[j]=pro[i].claim[j];}}printf("\n");}int safe(){ int work[101];int finish[101];int xulie[101];int i,j,k,w=0;int flag=1,t=0;for(i=0;i<m;i++)finish[i]=0;for(i=0;i<n;i++)work[i]=available[i];for(i=0;i<m;i++){for(j=0;j<m;j++){if(finish[j]==0){for(k=0;k<n ;k++){if(flag==1&&work[k]>=pro[j].need[k])flag=1;elseflag=0;}if(flag==1){for(k=0;k<n;k++)work[k]=work[k]+pro[j].allocation[k];finish[j]=1;xulie[w++]=j;}flag=1;}}}for(i=0;i<m;i++)if(finish[i]==0) break;if(i<m){printf("系统是不安全的,进程等待,请重新输入进程\n");return 0;}else{printf("系统是安全的。
c语言银行家算法实验报告
c语言银行家算法实验报告C语言银行家算法实验报告引言:计算机科学领域中,操作系统的资源管理是一个十分重要的课题。
在多任务处理系统中,多个进程同时竞争有限的资源,如何合理地分配和调度资源,以保证系统的稳定性和效率,是一个关键问题。
银行家算法(Banker's Algorithm)是一种经典的资源分配算法,它通过分析系统的资源状态和进程的资源需求,来判断是否能够安全地分配资源,从而避免产生死锁。
一、实验目的本次实验旨在通过C语言编程实现银行家算法,加深对资源管理和死锁问题的理解,并通过实际案例验证银行家算法的有效性。
二、实验环境本次实验使用C语言进行编程,并在Linux操作系统下进行测试。
三、实验过程1. 设计数据结构在开始编写代码之前,我们需要先设计适合的数据结构来表示系统资源和进程的状态。
在银行家算法中,我们需要记录系统中的可用资源数量、各个进程的最大需求资源数量、已分配资源数量和需要资源数量等信息。
通过定义合适的数据结构,我们可以方便地进行资源的分配和回收。
2. 实现银行家算法根据银行家算法的原理,我们可以将其分为两个步骤:安全性检查和资源分配。
在安全性检查中,我们需要判断当前系统状态下是否存在安全序列,即是否能够满足所有进程的资源需求,避免死锁的发生。
在资源分配中,我们需要根据当前系统状态和进程的资源需求,动态地分配和回收资源。
3. 编写测试用例为了验证银行家算法的正确性和有效性,我们需要编写一些测试用例。
测试用例应该包括各种不同的进程资源需求和系统资源状态,以覆盖不同情况下的资源分配和回收。
4. 运行测试用例在编写完测试用例后,我们可以运行程序,观察输出结果。
通过比较实际输出与预期结果,我们可以判断银行家算法的正确性和有效性。
四、实验结果与分析通过运行多个测试用例,我们可以得出以下结论:1. 银行家算法能够有效地避免死锁的发生。
在安全性检查过程中,如果存在安全序列,那么系统可以继续分配资源,否则需要阻塞等待。
银行家算法 实验报告
淮海工学院计算机工程学院实验报告书课程名:《操作系统原理》题目:银行家算法班级:学号:姓名:一、实验目的银行家算法是操作系统中避免死锁的典型算法,本实验可以加深对银行家算法的步骤和相关数据结构用法的更好理解。
实验环境TurboC2.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语言代码实现
操作系统银⾏家算法C语⾔代码实现 计算机操作系统课设需要,写了两个下午的银⾏家算法(陷在bug⾥出不来耽误了很多时间),参考计算机操作系统(汤⼦瀛) 实现过程中不涉及难度较⼤的算法,仅根据银⾏家算法的思想和步骤进⾏实现。
以下为详细步骤: 定义:max1[ ][ ] : 最⼤需求矩阵,max1[i][j]为第i条进程的第j项资源的最⼤需求数⽬; allocation[ ][ ] : 分配矩阵,allocation[i][j]为第i条进程已分得的第j项资源的数⽬; need[ ][ ] : 需求矩阵,need[i][j]为第i条进程尚需要的第j项资源的数⽬; available[ ] : 可利⽤资源量,available[i]为系统中第i项资源的可分配数⽬; request[ ][ ] : 请求矩阵,request[i][j]表⽰第i条进程对第j项资源的请求数⽬;//可以改成⼀维数组 int safe (int n,int m,int work) : n条进程,m项进程,返回值为1时当前状态安全,否则不安全; 程序流程: 1. 键盘输⼊max1矩阵,allocation矩阵,available数组,计算出need矩阵。
2. 判断当前时刻系统的状态是否安全。
true 转向3,false转向7 3. 判断当前时刻request<=need。
true 转向4,false 转向7 4. 判断当前时刻request<=available。
true 转向5,false 转向75. 进⾏安全性算法检测。
true 转向6,false 转向76. 系统分配资源并继续等待指令。
7. 系统不予分配资源并输出原因。
安全性算法:每次从第⼀个进程开始检测,如遇到所有的m项资源都可以满⾜时,work+=allocation,否则转⼊下⼀个进程的检测。
两种情况跳出第20⾏的循环。
1. 所有finish均为1,i⽆法置为-1 ,i==N时跳出循环2. 存在为0的finish,但直⾄i==N时,仍未有新的work<need出现(从最近的⼀次i==-1算起),i==N时跳出循环 第50⾏进⾏检测区分上述两种情况,如安全返回1,否则返回0;以下为完整的代码实现:(另附测试数据)1 #include<bits/stdc++.h>2int max1[1000][1000]= {0};3int allocation[1000][1000]= {0};4int need[1000][1000]= {0};5int finish[1000]= {0};6int available[1000]= {0};7int request[1000][1000]= {0};8int waitq[1000]= {0};9int waitnum=0;10int safeq[1000]= {0};11int safe (int N , int M ,int work[])12 {13int s=0;14 memset(finish,0,1000*sizeof(int));15for(int i=0; i<M; i++)16 {17 work[i]=available[i];18 }19int flag=1;20for(int i=0; i<N; i++)21 {22 flag=1;23if(!finish[i])24 {25for(int j=0; j<M; j++)26 {27if(need[i][j]>work[j])28 {29 flag=0;30break;31 }32 }33if(flag)34 {35for(int j=0; j<M; j++)36 {37 work[j]+=allocation[i][j];38 printf(" %d ",work[j]);39 }40for(int j=0; j<3; j++)41 printf("%d ",available[j]);42 printf("program %d\n",i);43 safeq[s++]=i;44 finish[i]=1;45 i=-1;46 }47 }48 }49int te=1;50for(int i=0; i<5; i++)51if(!finish[i])52 te=0;53return te;54 }55void print(int pn,int yn)56 {57 printf("current status\n");58char a='A';59int i2=0;60for(i2=0; i2<4; i2++)61 {62switch(i2)63 {64case0:65 printf("Max:");66for(int i=0; i<yn-1; i++)67 printf("");68 printf("");69break;70case1:71 printf("Allocation:");72for(int i=0; i<yn-3; i++)73 printf("");74 printf("");75break;76case2:77 printf("Need:");78for(int i=0; i<yn-1; i++)79 printf("");80break;81case3:82 printf("Available:");83for(int i=0; i<yn-2; i++)84 printf("");85 printf("");86 printf("\n");87break;88 }89 }90for(i2=0; i2<4; i2++)91 {92switch(i2)93 {94case0:95for(int j=0; j<yn; j++)96 printf("%c ",a+j);97break;98case1:99for(int j=0; j<yn; j++)100 printf("%c ",a+j);101break;102case2:103for(int j=0; j<yn; j++)104 printf("%c ",a+j);105break;106case3:107for(int j=0; j<yn; j++)108 printf("%c ",a+j);109break;110111 }112 }113 printf("\n");114for(int i=0; i<pn; i++)115 {116for(int j=0; j<yn; j++)117 {118 printf("%d ",max1[i][j]);119 }120for(int j=0; j<yn; j++)121 {122 printf("%d ",allocation[i][j]);123 }124for(int j=0; j<yn; j++)125 {126 printf("%d ",need[i][j]);127 }128if(i==0)129for(int j=0; j<yn; j++)130 printf("%d ",available[j]);131 printf("\n");132 }133 }134int main()135 {136int work[1000]= {0};137int pn,yn;138 printf("Please input the number of the program\n");139 scanf("%d",&pn);140 printf("Please input the number of the element\n");141 scanf("%d",&yn);142 printf("Please input Max and Allocation of the program \n");143for(int i=0; i<pn; i++)144 {145for(int j=0; j<yn; j++)146 {147 scanf("%d",&max1[i][j]);148 }149for(int j=0; j<yn; j++)150 {151 scanf("%d",&allocation[i][j]);152 }153for(int j=0; j<yn; j++)154 {155 need[i][j]=max1[i][j]-allocation[i][j];156 }157 }158 printf("Please input the Available \n");159for(int i=0; i<yn; i++)160 {161 scanf("%d",&available[i]);162 work[i]=available[i];163 }164165if(safe(pn,yn,work))166 {167 printf("it is safe now \n");168for(int i=0; i<pn; i++)169 printf("%d ",safeq[i]);170 printf("\n");171 printf("is the one of the safe sequence \n");172 }173else174 printf("it is not safe now\n");175176177if(safe(pn,yn,work))178 {179while(1)180 {181int num;182int ex;183int judge=1;184 printf("if you want to exit , please input 0 else input 1 \n"); 185 scanf("%d",&ex);186if(!ex)187break;188 printf("Please input the number of the request program \n"); 189 scanf("%d",&num);190 printf("Please input the Request \n");191for(int i=0; i<yn; i++)192 {193 scanf("%d",&request[num][i]);194if(request[num][i]>need[num][i])195 {196 judge=0;197 printf("error!\n");198break;199 }200 }201if(judge)202 {203int wait=0;204for(int i=0; i<yn; i++)205 {206if(request[num][i]>available[i])207 {208 wait=1;209 printf("wait because request>available!\n"); 210break;211 }212 }213if(!wait)214 {215216for(int j1=0; j1<yn; j1++)217 {218 available[j1]-=request[num][j1];219 allocation[num][j1]+=request[num][j1]; 220 need[num][j1]-=request[num][j1];221 }222if(safe(pn,yn,work))223 {224 printf("it is safe now \n");225for(int i=0; i<pn; i++)226 printf("%d ",safeq[i]);227 printf("\n");228 printf("is the one of the safe sequence \n"); 229 printf("complete !!!!!!!\n");230 }231else232 {233for(int j1=0; j1<yn; j1++)234 {235 available[j1]+=request[num][j1];236 allocation[num][j1]-=request[num][j1]; 237 need[num][j1]+=request[num][j1];238 }239 printf("wait because it is not safe \n"); 240 }241 }242243 }244 }245 }246 print(pn,yn);247 }248249/*250525132527 5 3 0 1 02533 2 2 2 0 02549 0 2 3 0 22552 2 2 2 1 12564 3 3 0 0 22573 3 2258125912601 0 2261126242633 3 0264126502660 2 02670268269270*/。
银行家算法实验报告c语言
银行家算法实验报告c语言银行家算法实验报告引言:计算机科学中的银行家算法是一种资源分配和避免死锁的算法。
它是由艾德加·戴克斯特拉(Edsger Dijkstra)在1965年提出的。
银行家算法通过判断一个系统是否处于安全状态来决定是否分配资源给进程。
本实验旨在使用C语言实现银行家算法,并通过一系列的实例来验证其有效性。
一、实验背景银行家算法是为了解决资源分配中的死锁问题而提出的。
在多进程系统中,每个进程都需要一定数量的资源来完成任务。
然而,如果资源分配不当,可能会导致死锁的发生,即所有进程都陷入无法继续执行的状态。
银行家算法通过合理地分配资源,避免了死锁的发生。
二、实验目的本实验的主要目的是通过C语言实现银行家算法,并通过实例验证其正确性和有效性。
具体而言,我们将模拟一个系统中的多个进程,并为每个进程分配资源。
然后,我们将使用银行家算法来判断系统是否处于安全状态,从而决定是否继续分配资源。
三、实验过程1. 创建进程和资源我们首先创建了5个进程和3种资源。
每个进程需要的资源数量是随机生成的,以模拟真实情况下的资源需求。
2. 分配资源根据银行家算法的原则,我们按照以下步骤来分配资源:- 首先,检查每个进程的资源需求是否小于等于系统当前可用的资源数量。
- 如果满足条件,将资源分配给该进程,并更新系统剩余资源数量。
- 如果不满足条件,暂时不分配资源给该进程,继续检查下一个进程。
3. 判断系统状态在每次资源分配后,我们需要判断系统是否处于安全状态。
为此,我们使用银行家算法的核心原则:只有当系统能够为每个进程提供所需的资源时,系统才是安全的。
我们通过遍历所有进程来检查其资源需求是否小于等于系统剩余资源数量,如果满足条件,说明系统是安全的。
4. 实例验证我们进行了多个实例验证,以确保银行家算法的正确性。
在每个实例中,我们模拟了不同的进程和资源需求,并观察系统的状态。
通过比较实验结果和预期结果,我们验证了银行家算法的有效性。
操作系统课程设计银行家算法模拟实现
操作系统课程设计银行家算法模拟实现操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导老师完成日期信息工程学院题目:银行家算法的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进展的一次全面的综合训练,通过课程设计,更好地掌握操作系统的原理及实现方法,加深对操作系统根底理论和重要算法的理解,加强学生的动手才能。
二、设计内容 1〕概述用C或C++语言编制银行家算法通用程序,并检测所给状态的系统平安性。
1.算法介绍:数据构造:1〕可利用资向量 Available;2〕最大需求矩阵Max;3〕分配矩阵Allocation;4〕需求矩阵Need 2.功能介绍模拟实现Dijkstra的银行家算法以防止死锁的出现,分两局部组成:第一局部:银行家算法〔扫描〕;第二局部:平安性算法。
2〕设计原理一.银行家算法的根本概念 1、死锁概念。
在多道程序系统中,虽可借助于多个进程的并发执行,来改善系统的资利用率,进步系统的吞吐量,但可能发生一种危险━━死锁。
所谓死锁(Deadlock),是指多个进程在运行中因争夺资而造成的一种僵局(Deadly_Embrace),当进程处于这种僵持状态时,假设无外力作用,它们都将无法再向前推进。
一组进程中,每个进程都无限等待被该组进程中另一进程所占有的资,因此永远无法得到的资,这种现象称为进程死锁,这一组进程就称为死锁进程。
2、关于死锁的一些结论:Ø参与死锁的进程最少是两个Ø〔两个以上进程才会出现死锁〕Ø参与死锁的进程至少有两个已经占有资Ø参与死锁的所有进程都在等待资Ø参与死锁的进程是当前系统中所有进程的子集注:假如死锁发生,会浪费大量系统资,甚至导致系统崩溃。
3、资分类。
永久性资:可以被多个进程屡次使用〔可再用资〕l 可抢占资 l 不可抢占资临时性资:只可使用一次的资;如信号量,中断信号,同步信号等〔可消耗性资〕“申请--分配--使用--释放”形式 4、产生死锁的四个必要条件:互斥使用〔资独占〕、不可侵占〔不可剥夺〕、恳求和保持〔局部分配,占有申请〕、循环等待。
操作系统实验报告银行家算法
南昌大学实验报告---(3)编程实现银行家安全算法学生姓名: 张虹 学 号: 6100409033 专业班级: 电Ⅲ091班 实验类型:□ 验证 ■ 综合 □ 设计 □ 创新 实验日期: 实验成绩:一、实验目的通过实验加强对银行家安全算法的理解和掌握。
二、实验内容熟悉避免死锁发生的方法,死锁与安全序列的关系,编程实现银行家算法,要求输出进程的安全序列。
三、实验要求1、 需写出设计说明;2、 设计实现代码及说明3、 运行结果;四、主要实验步骤1、 分析银行家算法结构;2、 画出银行家算法的流程图,即设计说明;3、 根据画出的流程图使用C 语言编写相应的代码(代码过长,放到最后);程序主要由main 函数和以下几个函数组成: void input();用户输入银行家算法的初始数据; void output();输出当前系统资源分配情况;void change();当请求资源满足要求时,进行分配,系统资源发生改变; int check();安全性算法,检查是否存在安全序列; void outputsafe();输出安全序列的资源分配表。
4、 检查代码,将编出的代码编译、链接,验证其正确性。
开始输入银行家算法初始数据执行安全性算法数据是否正确是否存在安全序列输入进程Pi 发出的请求向量请求资源是否小于需求资源系统将资源分配给Pi执行算法的是否为初始数据结束资源分配无效,恢复分配前的系统资源情况输出当前资源分配表NYNYNY输出安全序列的资源情况是否有进程发出请求向量NYNY请求资源是否小于系统资源Y进程Pi 需等待NY五、实验数据及处理结果六、实验体会或对改进实验的建议体会:编写银行家算法需要较好分析能力,C语言也要掌握的很好,而且需要细心和极大地耐心。
我的程序在最开始编出来的第一份代码编译时大大小小一堆错误,有些是一个小错误导致了下面全错,这些小错误在一百多行里找起来非常费劲。
然后小错误全部找出来以后,再编译,错误没有了,但是得到的结果却是错误的,这样又要开始一行一行分析,看是哪里出了问题。
操作系统实验银行家算法C语言实现
#include<stdio.h>#include<stdlib.h>#include<string.h>#define a 10#define b 10//****银行家算法中的数据结构***********************int Available[a]; //.............各资源可利用的数量int Max[b][b]; //..................各进程对各类资源的最大需求数int Allocation[b][b]; //.............各进程当前已分配的资源数量int Need[b][b]; //.................尚需多少资源//*************************************************int Request[a]; //.................申请多少资源int Work[a]; //...................工作向量,表示系统可提供给进程继续运行所需的各类资源数量int Finish[b]; //...................表示系统是否有足够的资源分配给进程,1为是//**********函数声明************************************void init();//..................创建进程,资源种类与分配等,初始化函数int banker();//..........................银行家分配算法void safe(); //...........................判断算法的安全性//**********************************************//******过程中定义的全局变量********************int i,j,x,y,l,counter=0;int p; //记录是哪个进程正在申请资源int q[b]; //存储安全序列//*************************************************//*************************创建进程*************************void init()//初始化{printf("输入当前进程量:\n");scanf("%d",&x);printf("输入资源的种类数目:\n");scanf("%d",&y);printf("***输入各种资源当前可用的数量***\n");for( i=0;i<y;i++){printf("请输入资源%d的资源可利用量\n",i);scanf("%d",&Available[i]);Work[i]=Available[i]; //初始化Work[i],它的初始值就是当前可用的资源数}printf("请输入每个进程申请到的资源\n");for( j=0;j<x;j++){for(i=0;i<y;i++){printf("请输入进程%d的申请到的资源%d:\n",j,i);scanf("%d",&Allocation[j][i]);}Finish[j]=0;//初始化Finish[j]}printf("请输入每个进程需要的最大的资源数目:\n");for(j=0;j<x;j++){for(i=0;i<y;i++){printf("请输入进程%d需要的最大的资源数目%d:\n",j,i);scanf("%d",&Max[j][i]);if (Max[j][i]>=Allocation[j][i]) //根据需求量=需要最大资源数目-已分配数目,计算需求量needNeed[j][i]=Max[j][i]-Allocation[j][i];elseNeed[j][i]=0;//资源充足,不需要再申请}}printf("初始化完成\n");}//安全性算法函数void safe(){l=0;for (j=0; j<y;j++){if (Finish[j]==0){ //逐个查找Finish[j]==0的进程条件一counter=0; //记数器for (i=0; i<x; i++){ if (Work[i]>=Need[j][i])counter=counter+1;//可用大于需求,记数}if(counter==x) //i进程的每类资源都符合Work[i]>=Need[j][i] 条件二{ q[l]=j; //存储安全序列Finish[j]=1; //i进程标志为可分配for (i=0; i<x;i++)Work[i]=Work[i]+Allocation[j][i]; //释放资源l=l+1; //记数,现在有L个进程是安全的,当L=N时说明满足安全序列j= -1; //从第一个进程开始继续寻找满足条件一二的进程}}}}//*************************银行家算法***********************int banker()//..........................银行家分配算法{printf("请输入请求资源的进程\n");scanf("%d",&p);printf("\n请输入此进程请求各种资源的个数\n");for(i=0;i<x;i++){do {printf("进程%d申请资源%d的数量",p,i);scanf("%d",&Request[i]);if(Request[i]>Need[p][i])//申请量不能超过需求量printf("申请量超过需求量出错;!!请重新输入!!\n");else if(Request[i]>Available[i]){ printf("资源不充足,目前可用资源只有%d,进程要等待!!",Available[i]);Finish[p]=0; //该进程等待return 0;}}while(Request[i]>Need[p][i]||Request[i]>Available[i]);for (i=0; i<x; i++){Available[i]=Available[i]-Request[i];Allocation[p][i]=Allocation[p][i]+Request[i];Need[p][i]=Need[p][i]-Request[i];Work[i]=Available[i];}//改变Avilable、Allocation、Need的值}//判断银行家算法的安全性if(l<x){l=0;printf("试分配不成功,不与分配,恢复原状态!!");for (i=0; i<x; i++){Available[i] = Available[i]+Request[i];Allocation[p][i] = Allocation[p][i]-Request[i];Need[p][i] = Need[p][i]+Request[i];Work[i] = Available[i];}for (j=0; j<y; j++)Finish[j]=0; //进程置为未分配状态}else{l=0;printf("\n申请资源成功\n");for(i=0;i<x;i++){if(Need[p][i]==0);else { //有一种资源还没全部申请到,该进程还处于就绪态l=1; //判断标志break;}}if(l!=1){ //进程可以执行,释放该进程的所有资源for (i=0;i<x;i++){Available[i]=Available[i]+Allocation[p][i];Allocation[p][i]=0;}printf("有需求资源,执行后将释放其所有拥有资源!");l=0; //归零printf("安全序列为:\n");printf("进程%d",q[0]); //输出安全序列,考虑显示格式,先输出第一个Finish[0]=0;for (i=1; i<y; i++){printf(" 进程%d",q[i]);Finish[i]=0; //重新将所有进程置为未分配状态}printf(" \n\n\n");}return 0;}void main(){printf("\n************************************************************\n"); printf("\n 银行家算法模拟\n");printf("\n************************************************************\n"); init();//safe(); //判断当前状态的安全性if(l<y)printf("找不到安全序列,拒绝申请\n");else{int m;printf("当前序列是安全的,安全序列为:\n");printf("进程%d\n",q[0]);Finish[m]=0;for(m=1;m<x;m++){printf("进程%d\n\n",q[m]);Finish[m]=0;}}banker(); //调用银行家算法函数}。
操作系统实验报告 银行家算法
昆明理工大学信息工程与自动化学院学生实验报告(201 —201 学年第二学期)课程名称:操作系统开课实验室:年月日一、实验目的通过编写银行家算法,要求学生进一步掌握如何实现死锁的避免,进一步熟练使用数组进行程序的设计及实现。
二、实验原理及基本技术路线图(方框原理图)用C语言或C++语言开发。
实现银行家算法、安全性检测算法。
有能力的同学再完成死锁检测算法。
数据结构定义及主要变量:int available[m]; //系统可用资源int claim[n, m]; //进程最大需求int allocation[n, m]; //进程当前已分配资源int need[n, m]; //进程尚需要的资源int request[ n, m]; //进程当前请求的资源临时变量(安全检查时用):int work[m]; //可分配资源和已分配资源之和int finish[n]; //检查时标识是否有未完成进程流程图:三、所用仪器、材料(设备名称、型号、规格等)。
计算机一台四、实验方法、步骤程序源代码:#include <stdio.h>#define M 100#define N 50//全局变量定义int Available[M]; //可利用资源数组int Max[N][M]; //最大需求矩阵int Allocation[N][M]; //分配矩阵int Need[N][M]; //需求矩阵int Request[N][M]; //M个进程还需要N类资源的资源量int Finish[N];int p[N];int m,n; //M个进程,N类资源//安全性算法int Safe(){int i,j,l=0;int Work[M]; //可利用资源数组for (i=0;i<n;i++)Work[i]=Available[i];for (i=0;i<m;i++)Finish[i]=0;for (i=0;i<m;i++){if (Finish[i]==1)continue;else{for (j=0;j<n;j++){if (Need[i][j]>Work[j])break;}if (j==n){Finish[i]=1;for(int k=0;k<n;k++)Work[k]+=Allocation[i][k];p[l++]=i;i=-1;}else continue;}if (l==m){printf("系统是安全的\n");printf("系统安全序列是:\n");for (i=0;i<l;i++){printf("%d",p[i]);if (i!=l-1)printf("-->");}printf("\n");return 1;}}}//银行家算法int main(){int i,j,mi;printf("请输入进程的数目:\n");scanf("%d",&m);printf("请输入资源的种类:\n");scanf("%d",&n);printf("输入每个进程对资源的最大需求量,按照%d*%d矩阵输入\n",m,n);for (i=0;i<m;i++)for(j=0;j<n;j++)scanf("%d%d",&Max[i][j]);printf("输入每个进程资源的目前占有量,按照%d*%d矩阵输入\n",m,n);for (i=0;i<m;i++){for(j=0;j<n;j++){scanf("%d%d",Allocation[i][j]);Need[i][j]=Max[i][j]-Allocation[i][j];if (Need[i][j]<0){printf("你输入的第%d个进程所拥有的第%d个资源错误,请重新输入:\n",i+1,j+1);j--;continue;}}}printf("请输入系统剩余资源量:\n");for (i=0;i<n;i++)scanf("%d",&Available[i]);Safe();while (1){printf("输入要申请的资源的进程号:(第一个进程号为0,第二个进、程号为1,依此类推)\n");scanf("%d",&mi);printf("输入进程所请求的各个资源的数量\n");for (i=0;i<n;i++){if (Request[mi][i]>Need[mi][i]){printf("所请求资源数超过进程的需求量!\n");return 0;}if (Request[mi][i]>Available[i]){printf("所请求资源数超过系统所有的资源数!\n");return 0;}}for (i=0;i<n;i++){Available[i]-=Request[mi][i];Allocation[mi][i]+=Request[mi][i];Need[mi][i]-=Request[mi][i];}if (Safe())printf("同意分配请求\n");else{printf("SORRY你的请求被拒绝\n");for (i=0;i<n;i++){Available[i]+=Request[mi][i];Allocation[mi][i]-=Request[mi][i];Need[mi][i]+=Request[mi][i];}}for (i=0;i<m;i++)Finish[i]=0;char Flag; //标志位printf("是否再次请求分配?是请按Y/y,否请按N/n"); while (1){scanf("%d",&Flag);if (Flag=='Y'||Flag=='y'||Flag=='N'||Flag=='n') break;else{printf("请按要求重新输入:\n");continue;}}if (Flag=='Y'||Flag=='y')continue;else break;}}五、实验过程原始记录(数据、图表、计算等)程序运行截图:六、实验结果、分析和结论(误差分析与数据处理、成果总结等。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
db->(r1,r2,r3);
c=(db,pi);
(db,c);
cout<<endl;
break;
}
case 0:
{break;}
default:
{cout<<"input error!try again!\n";break;}
}
}
}
}
void displaySafeList(Data *db)urrentAvail);
cout<<" ";
displaySource(db->p[db->ruler[i]].claim);
cout<<" ";
displaySource(db->p[db->ruler[i]].allocation);
操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源,否则就推迟分配。当进程在执行中继续申请资源时,先测试该进程本次申请的资源数是否超过了该资源所剩余的总量。若超过则拒绝分配资源,若能满足则按当前的申请量分配资源,否则也要推迟分配。
操 作 系 统
实
验
报
告
(2)
学院:计算机科学与技术学院
班级:计091
学号:姓名:
时间:2011/12/30
1.实验名称……………………………………………………3
2.实验目的……………………………………………………3
3.实验内容……………………………………………………3
4.实验要求……………………………………………………3
db->p[db->ruler[i-1]].allocation);
db->p[db->ruler[i]].currentAvail))
{return false;}
db->sum))
{return false;}
}
return true;laim_allocation))
{return 1;}
Source s(db->p[i].allocation);db->ask);
cout<<" ";
displaySource(db->p[db->ruler[i]].claim_allocation);
cout<<" true";
cout<<endl;
}
}
void displayAskResult(Data *db,int n)db->available);db->p[db->ruler[i]].currentAvail))db->p[db->ruler[i-1]].currentAvail);
int pi;
while(choice)
{
cout<<"\n 选择操作:\n 1 查看进程情况\n 2 请求分配资源\n 0 退出\n ";
cin>>choice;
switch(choice)
{
case 1:
{
cout<<"当前资源量available[R1,R2,R3]:\n ";
(db->available);
5.实验原理……………………………………………………3
6.实验环境……………………………………………………4
7.实验设计……………………………………………………4
数据结构设计……………………………………………………………………4
算法设计…………………………………………………………………………6
功能模块设计……………………………………………………………………7
8.实验运行结果………………………………………………8
9.实验心得……………………………………………………9
附录:源代码(部分)…………………………………………………………………9
一、实验名称:
用C++实现银行家算法
二、实验目的:
通过自己编程来实现银行家算法,进一步理解银行家算法的概念及含义,提高对银行家算法的认识,同时提高自己的动手实践能力。
各种死锁防止方法能够阻止发生死锁,但必然会降低系统的并发性并导致低效的资源利用率。死锁避免却与此相反,通过合适的资源分配算法确保不会出现进程循环等待链,从而避免死锁。本实验旨在了解死锁产生的条件和原因,并采用银行家算法有效地防止死锁的发生。
三、实验内容:
利用C++,实现银行家算法
四、实验要求:
1.完成银行家算法的设计
if(!db)
{cout<<"error!no enough memory space!";return;}
DataInit dataInit;
(db);//设置进程个数
(db);//设置系统总资源量
(db);//设置当前系统可获得资源量
(db);//设置t0时刻进程基本状态
Display display;
db->p[db->ruler[i-1]].allocation);
db->p[db->ruler[i]].currentAvail))
{return false;}
db->sum))
{return false;}
}
return true;laim_allocation))
{return 1;}
Source s(db->p[i].allocation);db->ask);
db->p[i].(db->ask);
if(!exsitSafeList(db))db->ask);
db->p[i].(db->ask);
return 2;
}
db->(0,0,0);//找到安全序列,将请求资源置零,返回3
return 3;
}
};
void main()
{
Data *db;
db=new Data;
六、实验环境:
Win-7系统
Visual C++
七、实验设计:
1.数据结构设计
定义结构体:
struct Process0, 0, 0);}
}
};
class DataInit法设计
class FindSafeListdb->available);db->p[db->ruler[i]].currentAvail))db->p[db->ruler[i-1]].currentAvail);
安全状态:如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态。安全状态一定是没有死锁发生。
不安全状态:不存在一个安全序列。不安全状态不一定导致死锁。
我们可以把看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。
为保证资金的安全,银行家规定:
(1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;
(2) 顾客可以分期贷款,但贷款的总数不能超过最大需求量;
(3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;
(4) 当顾客得到所需的全部资金后,一定能在有限的时间里归还所b->ask);
if(!exsitSafeList(db))db->ask);
db->p[i].(db->ask);
return 2;
}
db->(0,0,0);能模块设计
class Data 0, 0, 0);}
}
};
class DataInitr1,r2,r3);
cout<<'p'<<i<<" max allocation(claim[R1,R2,R3]): ";r1,r2,r3);
r1=db->p[i].>p[i].;p[i].;
r3=db->p[i].>p[i].;
db->p[i].(r1, r2, r3);
}
}
};
class Displaylaim);
cout<<"\t\t";
displaySource(p[i].allocation);
cout<<endl;
}
cout<<endl;
银行家算法是一种最有代表性的避免的算法。在避免死锁方法中允许进程动态地申请资源,但系统在进行资源分配之前,应先计算此次分配资源的安全性,若分配不会导致系统进入不安全状态,则分配,否则等待。为实现银行家算法,系统必须设置若干。要解释银行家算法,必须先解释操作系统安全状态和不安全状态。安全序列是指一个进程序列{P1,…,Pn}是安全的,如果对于每一个进程Pi(1≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
FindSafeList findSafeList;
int r1=0,r2=0,r3=0;
int c;
db->(r1,r2,r3);//设置请求资源为0,即无请求
c=(db,0);//寻找安全序列,返回结果