操作系统实验报告--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.设计3-4个并发进程，共享系统的10个同类不可抢占的资源。
各进程动态进行资源的申请和释放。
2.用银行家算法和随机算法分别设计一个资源分配程序，运行这两个程序，观察系统运行情况，并对系统运行的每一步情况进行显示。
二、总的设计思想及语言环境、工具等1.算法设计思路银行家算法又称“资源分配拒绝”法，其基本思想是，系统中的所有进程放入进程集合，在安全状态下系统受到进程的请求后试探性的把资源分配给他，现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较，找出剩余资源能满足最大需求量的进程，从而保证进程运行完成后还回全部资源。
这时系统将该进程从进程集合中将其清除。
此时系统中的资源就更多了。
反复执行上面的步骤，最后检查进程的集合为空时就表明本次申请可行，系统处于安全状态，可以实施本次分配，否则，只要进程集合非空，系统便处于不安全状态，本次不能分配给他，请进程等待。
2.语言环境、工具计算机基本配置要求：操作系统：WIN 98/2000/XP/2003 等Windows平台内存：256MB及以上主存64KB（Memory）（以KB为单位分配）开发语言：Visual C++ 6.0四、数据结构与模块说明（功能与框图）五、源程序（指导老师验收通过）#include<string.h>#include<iostream.h>#define FALSE 0#define TRUE 1#define W 10 //最大进程数W=10#define R 20 //最大资源总数R=20int M ;int N ;int ALL_RESOURCE[W];int AVAILABLE[R]; //可利用资源向量int MAX[W][R]; //最大需求矩阵int ALLOCATION[W][R]; //分配矩阵int NEED[W][R]; //需求矩阵int Request[R]; //进程请求向量void inputdata(); //数据输入void showdata(); //数据显示void changdata(int k);//进程请求资源数据改变void restoredata(int k); //数据恢复int chksec(int s); //系统安全性的检测int chkmax(int s); //检测最大需求void bank(); //检测分配的资源是否合理void main(){ int i,j;inputdata();for(i=0;i<M;i++){ j=chksec(i);if (j==0) break;}if (i>=M)cout<<"错误提示：经安全性检查发现，系统的初始状态不安全\n"<<endl;else{ cout<<"提示：经安全性检查发现，系统的初始状态安全！"<<endl;bank();}}void inputdata(){ int i=0,j=0,p;cout<<"请输入总进程数:"<<endl;do{cin>>M;if (M>W) cout<<endl<<"总进程数超过了程序允许的最大进程数，请重新输入:"<<endl;}while (M>W);cout<<endl;cout<<"请输入资源的种类数:"<<endl;do {cin>>N;if (N>R)cout<<endl<<"资源的种类数超过了程序允许的最大资源种类数，请重新输入:"<<endl; }while (N>R);cout<<endl;cout<<"请依次输入各类资源的总数量，即设置向量all_resource:"<<endl;for(i=0;i<N;i++) cin>>ALL_RESOURCE[i];cout<<endl;cout<<"请依次输入各进程所需要的最大资源数量，即设置矩阵max:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do { cin>>MAX[i][j];if (MAX[i][j]>ALL_RESOURCE[j])cout<<endl<<"该最大资源数量超过了声明的该资源总数,请重新输入:"<<endl; }while (MAX[i][j]>ALL_RESOURCE[j]);}}cout<<endl;cout<<"请依次输入各进程已经占据的各类资源数量，即设置矩阵allocation:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do{ cin>>ALLOCATION[i][j];if (ALLOCATION[i][j]>MAX[i][j])cout<<endl<<"已占有的资源数量超过了声明的最大资源数量,请重新输入:"<<endl;}while (ALLOCATION[i][j]>MAX[i][j]);}}cout<<endl;for (i=0;i<M;i++)for(j=0;j<N;j++)NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];for (j=0;j<N;j++){ p=ALL_RESOURCE[j];for (i=0;i<M;i++){ p=p-ALLOCATION[i][j];AVAILABLE[j]=p;if(AVAILABLE[j]<0)AVAILABLE[j]=0;}}}void showdata(){ int i,j;cout<<"各种资源的总数量，即向量all_resource为:"<<endl;cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<ALL_RESOURCE[j];cout<<endl<<endl;cout<<"当前系统中各类资源的可用数量，即向量available为:"<<endl; cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<AVAILABLE[j];cout<<endl<<endl;cout<<"各进程还需要的资源数量，即矩阵need为:"<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<NEED[i][j]<<" ";cout<<endl;}cout<<endl;cout<<"各进程已经得到的资源量，即矩阵allocation为: "<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<ALLOCATION[i][j]<<" ";cout<<endl;} cout<<endl;}void changdata(int k){ int j;for (j=0;j<N;j++){AVAILABLE[j]=AVAILABLE[j]-Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];NEED[k][j]=NEED[k][j]-Request[j];}}void restoredata(int k){int j;for (j=0;j<N;j++){ AVAILABLE[j]=AVAILABLE[j]+Request[j];ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];NEED[k][j]=NEED[k][j]+Request[j];}}int chksec(int s){int WORK,FINISH[W];int i,j,k=0;for(i=0;i<M;i++)FINISH[i]=FALSE;for(j=0;j<N;j++){ WORK=AVAILABLE[j];i=s;do{ if(FINISH[i]==FALSE&&NEED[i][j]<=WORK){WORK=WORK+ALLOCATION[i][j];FINISH[i]=TRUE;i=0;}else{ i++;}}while(i<M);for(i=0;i<M;i++)if(FINISH[i]==FALSE){ return 1;}} return 0;}int chkmax(int s){ int j,flag=0;for(j=0;j<N;j++){if (MAX[s][j]==ALLOCATION[s][j]){ flag=1;AVAILABLE[j]=AVAILABLE[j]+MAX[s][j];MAX[s][j]=0;}} return flag;}c{int i=0,j=0;char flag='Y';while(flag=='Y'||flag=='y'){i=-1;while(i<0||i>=M){ cout<<"请输入需申请资源的进程号（从P0到P"<<M-1<<"，否则重新输入!）:"; cout<<"p";cin>>i;if(i<0||i>=M)cout<<"输入的进程号不存在，重新输入!"<<endl;}cout<<"请输入进程P"<<i<<"申请的资源数:"<<endl;for (j=0;j<N;j++){ cout<<" 资源"<<j<<": ";cin>>Request[j];if(Request[j]>NEED[i][j]){ cout<<"进程P"<<i<<"申请的资源数大于进程P"<<i<<"还需要"<<j<<"类资源的资源量!";cout<<"申请不合理，出错!请重新选择!"<<endl<<endl;flag='N';break;}else{ if(Request[j]>AVAILABLE[j]){ cout<<"进程P"<<i<<"申请的资源数大于系统可用"<<j<<"类资源的资源量!";cout<<"申请不合理，出错!请重新选择!"<<endl<<endl;flag='N';break;}}}if(flag=='Y'||flag=='y'){ changdata(i);if(chksec(i)){ cout<<endl;cout<<"该分配会导致系统不安全本次资源申请不成功，不予分配"<<endl;cout<<endl;restoredata(i);}else{ cout<<endl;cout<<"经安全性检查，系统安全，本次分配成功，且资源分配状况如下所示："<<endl;cout<<endl;showdata();if(chkmax(i)){cout<<"在资源分配成功之后，由于该进程所需的某些资源的最大需求量已经满足，"<<endl;cout<<"因此在进程结束后系统将回收这些资源！"<<endl;cout<<"在资源收回之后，各进程的资源需求和分配情况如下所示："<<endl;showdata();}}}cout<<endl;cout<<" 是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ";cin>>flag; }}六、运行结果分析1.输入进程数、资源种类数、各类资源总数量、各进程所需要的最大资源数量、各进程所已经占据的各类资源数量2.经安全性检验，系统状态安全，进程P0申请资源3.经安全性检验，系统状态安全，进程P0获得所申请资源4.进程P3申请资源5.经安全性检验，系统状态安全，进程P3获得所申请资源6.进程P1申请资源7.经安全性检验，系统状态安全，进程P1获得所申请资源8.进程P2申请资源9.经安全性检验，系统状态安全，进程P2获得所申请资源5.进程P1申请资源6.经安全性检验，系统状态安全，进程P1获得所申请资源七、总结这次实验中我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
C语言实验报告范例
C语言实验报告范例
实验题目：C语言实现银行家算法
实验目的：掌握C语言实现银行家算法的基本思想，并能熟练应用矩阵处理实现银行
家算法的功能。
实验内容：
1. 利用C语言实现银行家算法的核心思想，利用矩阵处理实现其核心功能模块。
2. 银行家算法是一种负责实现“当前分配”的基于矩阵的编程模型。
该算法可以通
过利用安全状态来识别一次可行解，从而解决请求和分配资源的冲突问题。
3. 根据上述信息，我们设计了C语言实现银行家算法的基本框架，包括初始化步骤、可行性检查步骤、回滚步骤以及主步骤。
4. 在初始化步骤中，我们采用矩阵存储技术，将银行家算法中的各个参数保存起来，具体过程中采用数组存储。
5. 在可行性检查步骤中，我们判断当前系统状态是否处于安全状态，如果处于安全
状态，则继续完成下一步余额检查；否则，处理发生冲突时，回滚处理。
6. 在主步骤中，我们过程中判断若系统处于可行状态，则继续分配资源；否则，则
执行回滚操作，将系统恢复到上一状态。
实验结果和结论：
通过实验，我们学会了如何使用C语言来实现银行家算法，进而通过实现矩阵处理，
实现了该算法的核心功能模块。
此外，我们还学习了安全状态机制，进行系统可行性检查，和完成系统的分配工作，以达到有效地实现银行家算法的目的。
本次实验结论如下：
1. 通过C语言实现银行家算法中的核心功能模块，使系统的可行性检查得以有效实现；
2. 利用矩阵存储来实现系统的可行性检查，从而有效地节省时间和提高资源分配的
效率；
3. 通过回滚处理，有效地解决资源请求和分配冲突问题，使系统能够有效地实现安
全状态。
操作系统实验报告--银行家算法
操作系统实验报告二一：实验标题：实现死锁避免算法：银行家算法。
二：实验环境：操作系统：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] 问题和想法：。
计算机操作系统银行家算法实验报告
计算机操作系统实验报告一、实验名称：银行家算法二、实验目的：银行家算法是避免死锁的一种重要办法，通过编写一种简朴的银行家算法程序，加深理解有关资源申请、避免死锁等概念，并体会和理解死锁和避免死锁的具体实施办法。
三、问题分析与设计：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）。
操作系统课程设计实验报告用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; }}}}。
银行家算法实验报告
计算机操作系统实验报告一、实验名称：银行家算法二、实验目的：银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计：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）。
操作系统实验项目银行家算法
实验四、银行家算法（一）目的和要求银行家算法是由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<<"若满足申请，系统将进入不安全状态，可能导致死锁！";}}。
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. 实例验证我们进行了多个实例验证，以确保银行家算法的正确性。
在每个实例中，我们模拟了不同的进程和资源需求，并观察系统的状态。
通过比较实验结果和预期结果，我们验证了银行家算法的有效性。
操作系统实验报告银行家算法
南昌大学实验报告---（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语言也要掌握的很好，而且需要细心和极大地耐心。
我的程序在最开始编出来的第一份代码编译时大大小小一堆错误，有些是一个小错误导致了下面全错，这些小错误在一百多行里找起来非常费劲。
然后小错误全部找出来以后，再编译，错误没有了，但是得到的结果却是错误的，这样又要开始一行一行分析，看是哪里出了问题。
操作系统实验二(银行家算法)实验报告
实验二实验报告实验源码：#include "stdio.h"#include <iostream.h>#include <string.h>#define False 0 // 定义False#define True 1 // 定义Trueint Max[100][100] = {0}; // 各进程所需各类资源的最大需求int Avaliable[100] = {0}; // 系统可用资源char name[100] = {0}; // 资源的名称int Allocation[100][100] = {0}; // 系统已分配资源int Need[100][100] = {0}; // 还需要资源int Request[100] = {0}; // 请求资源向量int temp[100] = {0}; // 存放安全序列int Work[100] = {0}; // 存放系统可提供资源int M = 100; // 作业的最大数为100int N = 100; // 资源的最大数为100// 显示资源矩阵void showdata(){int i,j;printf("\n此时刻的资源分配情况为：\n");// 显示表头printf(" Max Allocation Need Avaliable\n");printf("PCB ");// 显示作业名称for(j = 0;j < 4;j++){for(i = 0;i < N;i++)printf("%c ",name[i]);printf(" ");}printf("\n");// 显示当前作业资源分配情况for(i = 0;i < M;i++){printf(" %d ",i);for(j = 0;j < N;j++)printf("%d ",Max[i][j]);printf(" ");for(j = 0;j < N;j++)printf("%d ",Allocation[i][j]);printf(" ");for(j = 0;j < N;j++)printf("%d ",Need[i][j]);if(i == 0){printf(" ");for (j = 0;j < N;j++)printf("%d ",Avaliable[j]);}printf("\n");}}// 进行资源分配int changdata(int i){int j;for (j = 0;j < M;j++) {Avaliable[j] = Avaliable[j] - Request[j];Allocation[i][j] = Allocation[i][j] + Request[j];Need[i][j] = Need[i][j] - Request[j];}return 1;}// 安全性算法int safe(){int i,d,k = 0,m,h,s,apply,Finish[100] = {0};int j;int flag = 0;for(i = 0;i < N;i++)Work[i] = Avaliable[i];printf(" 安全性检查\n");printf(" Work Need Allocation Work+Allocation Finish\n");printf("PCB ");// 显示作业名称for(j = 0;j < 4;j++){for(i = 0;i < N;i++)printf("%c ",name[i]);printf(" ");}printf("\n");// 显示当前作业资源分配情况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){printf(" %d ",i);for(d = 0;d < N;d++)printf("%d ",Work[d]);printf(" ");for(d = 0;d < N;d++)printf("%d ",Need[i][d]);printf(" ");for(d = 0;d < N;d++)printf("%d ",Allocation[i][d]);printf(" ");for(m = 0;m < N;m++){Work[m] = Work[m] + Allocation[i][m];printf("%d ",Work[m]);}// 变分配数Finish[i] = True;temp[k] = i;printf(" ");printf("true ");printf("\n");i = -1;k++;flag++;}}}}for(i = 0;i < M;i++){if(Finish[i] == False){for(j = 0;j < N;j++){Avaliable[j] = Avaliable[j] + Request[j];;Allocation[i][j] = Allocation[i][j] - Request[j];;Need[i][j] = Need[i][j] + Request[j];}printf("\n系统进入不安全状态！此时系统不分配资源！\n"); // 不成功系统不安全return 0;}}printf("\n此时系统是安全的!\n"); // 如果安全，输出成功printf("安全序列为:");for(i = 0;i<M;i++) // 输出运行进程数组{printf("%d",temp[i]);if(i < M - 1)printf("->");}printf("\n");return 0;}// 利用银行家算法对申请资源对进行判定void share(){char ch;int i = 0,j = 0;ch = 'y';printf("\n请输入要求分配的资源进程号(0 - %d):",M - 1);scanf("%d",&i); // 输入须申请的资源号printf("\n请输入进程%d 申请的资源:\n",i);for(j = 0;j < N;j++){printf("%c:",name[j]);scanf("%d",&Request[j]); // 输入需要申请的资源}for (j = 0;j < N;j++){if(Request[j] > Need[i][j]) // 判断申请是否大于需求，若大于则出错{printf("\n进程%d 申请的资源大于它需要的资源",i);printf(" 分配不合理，不予分配！\n");ch = 'n';break;} else {if(Request[j] > Avaliable[j]) // 判断申请是否大于当前资源，若大于则{// 出错printf("\n进程%d 申请的资源大于系统现在可利用的资源",i);printf(" 分配出错，不予分配！\n");ch = 'n';break;}}}if(ch == 'y') {changdata(i); // 根据进程需求量变换资源showdata(); // 根据进程需求量显示变换后的资源safe(); // 根据进程需求量进行银行家算法判断}}// 主函数int main(){int t = 1,i,j,number,choice,m,n,flag;char ming;printf("\n请首先输入系统可供资源种类的数量:");scanf("%d",&n);N = n;for(i = 0;i < n;i++){printf("资源%d 的名称:",i + 1);scanf("%s",&ming);name[i] = ming;printf("资源的数量:");scanf("%d",&number);Avaliable[i] = number;}printf("\n");printf("请输入作业的数量:");scanf("%d",&m);M = m;printf("\n请输入各进程的最大需求量( %d * %d 矩阵)[Max]:\n",m,n);for(i = 0;i < m;i++)for(j = 0;j < n;j++)scanf("%d",&Max[i][j]);do{flag = 0;printf("\n请输入各进程已经申请的资源量( %d * %d 矩阵)[Allocation]:\n",m,n);for(i = 0;i < m;i++)for(j = 0;j < n;j++){scanf("%d",&Allocation[i][j]);if(Allocation[i][j] > Max[i][j])flag = 1;Need[i][j] = Max[i][j] - Allocation[i][j];}if(flag)printf("\n申请的资源大于最大需求量，请重新输入！\n\n");}while(flag);showdata(); // 显示各种资源safe(); // 用银行家算法判定系统是否安全while(1){if(t == 1){printf("\n 利用银行家算法预分配资源\n");share();t = 0;}else break;printf("\n 是否继续银行家算法？(按1 键继续,按其它任意键退出):");scanf("%d",&t);printf("\n");}return 1;}实验结果截图：运行程序：输入相应数据并完成首次自检：进程1请求资源Request(1,0,2)：进程4请求资源Request(3,3,0)：进程0请求资源Request(0,2,0)：。
操作系统实验银行家算法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;}}五、实验过程原始记录(数据、图表、计算等)程序运行截图：六、实验结果、分析和结论（误差分析与数据处理、成果总结等。
银行家算法(用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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验报告附录3程序源代码：#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");}（程序结束）附录 4程序运行调试结果：1、程序初始化2、检测系统资源分配是否安全结果。