操作系统实验报告--c语言实现银行家算法【最新资料】
操作系统实验报告----银行家算法
操作系统实验报告----银行家算法班级：______计算机03(7)班______________ 姓名：_________李君益__________________ 学号：______________(61号)___提交日期：____06.7.11___________________ 指导老师: ______林穗____________________一、设计题目加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
要求编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用银行家算法，有效的防止和避免死锁的发生。
二、设计要求内容：编制银行家算法通用程序，并检测思考题中所给状态的安全性。
要求：(1)下列状态是否安全？(三个进程共享12个同类资源)进程已分配资源数最大需求数1 1 4 (状态a)2 4 43 5 81 1 42 4 6 (状态b)3 6 8(2)考虑下列系统状态分配矩阵最大需求矩阵可用资源矩阵0 0 1 2 0 0 1 2 1 5 2 01 0 0 0 1 7 5 01 3 5 423 5 60 6 3 2 0 6 5 20 0 1 4 0 6 5 6问系统是否安全？若安全就给出所有的安全序列。
若进程2请求(0420)，可否立即分配？三、设计分析一．关于操作系统的死锁1．死锁的产生计算机系统中有许多独占资源，他们在任一时刻只能被一个进程使用，如磁带机，绘图仪等独占型外围设备，或进程表，临界区等软件资源。
两个进程同时向一台打印机输出将导致一片混乱，两个进程同时进入临界区将导致数据库错误乃至程序崩溃。
正因为这些原因，所有操作系统都具有授权一个进程独立访问某一辞源的能力。
一个进程需要使用独占型资源必须通过以下的次序：●申请资源●使用资源●归还资源若申请施资源不可用，则申请进程进入等待状态。
对于不同的独占资源，进程等待的方式是有差别的，如申请打印机资源、临界区资源时，申请失败将一位这阻塞申请进程；而申请打开文件文件资源时，申请失败将返回一个错误码，由申请进程等待一段时间之后重试。
《操作系统》课程实验报告银行家算法
《操作系统》课程实验报告实验名称：银行家算法姓名：学号：地点：指导老师：专业班级：一、实验目的：1)对死锁避免中的银行家算法做进一步的理解。
2)加深理解死锁的概念3)加深理解安全序列和安全状态的概念4)通过编程，掌握银行家算法分配资源的一步步实现过程二、实验内容：1）给出系统可用资源向量2）给出当前状态系统中各个进程的资源分配情况3）根据系统当前资源状态和各个进程的资源分配情况，判断系统是否处于安装状态，若系统处于安全状态，给出所有的安全序列和每一个安全序列所对应的资源分配图，若系统不处于安全序列，则发出死锁警告。
三、实验主要代码/**银行家算法（实现所有存在路径的查找）*///构造进程单位struct Process{string p_name; //进程的名称int Max[N]; //进程对于各个资源的最大需求数目int Allocation[N]; //进程已经得到的各个资源的数目int Need[N]; // 进程对各个资源所需要的数目};int p_num, s_num; // 进程数、资源种类static struct Process P[N];int Available[N]; //系统中各个资源可用的数目void dfs(int step){/**银行家算法（实现所有存在路径的查找）搜寻所有的安全序列 */for (int i = 0; i < p_num; i++){back_time++; // 找到当前安全序列的时间点int flag = 0;if (vis[i]) continue;//判断现有的系统资源是否满足该进程的需求for (int j = 0; j < s_num; j++){if (Available[j] < P[i].Need[j]){flag = 1;break;}}if (flag) continue;vis[i] = true;//该进程运行完毕ans[step] = i;//将这个可以运行的进程编号存入数组当中// 回收资源for (int j = 0; j < s_num; j++)Available[j] += P[i].Allocation[j];//如果所有的进程都全部执行完毕if (step == p_num)Print(ans, p_num);dfs(step + 1);vis[i] = false;for (int j = 0; j < s_num; j++)Available[j] -= P[i].Allocation[j];}}四、实验过程分析本次实验的主要任务是实现银行家算法，通过输入当前某一时刻系统的资源数目和所有进程相关的资源信息，然后通过算法的实现判断当前系统是否处于不安全状态，如果是处于安全状态那么找到所有的安全序列。
操作系统银行家算法实验报告
实验五银行家算法一、实验目的和要求①理解死锁概念，银行家算法及安全检测算法。
②在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个。
《操作系统》综合实训报告-银行家算法
题目四银行家算法一、实验目的1、通过银行家算法理解操作系统安全状态和不安全状态。
2、理解银行家算法的避免死锁的主要思想。
3、通过实验更加深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法。
二、实验要求及内容实验要求：1、根据教材在T0时刻系统分配的资源，用银行家算法判断系统是否处于安全序列，它的安全序列怎样。
2、理解银行家算法的思想，独立编写银行家算法，实现对进程请求的判断和安全性的检测，是否存在安全序列。
实验内容：1、在window平台中，利用visual c++6.0环境编写c语言，模拟一个动态资源分配的银行家算法程序。
2、通过手动输入初始资源分配列表的值，手动输入进程请求的请求信息（进程号和资源请求数），后对系统进行安全性判断，求出安全序列。
3、手动进行进程请求的模拟输入，并通过算法判断，进程请求的合理性和剩余资源对请求的满足性，来对请求选择进行分配。
后对其序列进行安全性检测，如系统处于不安全状态，则对其进行恢复。
二、主要思想1、算法思路操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。
当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。
若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。
2、银行家算法和安全性检查算法原理银行家算法：银行家算法最初级原为银行系统设计，以确保银行在发放现金贷款时，不会发生不能满足所有客户需要的情况。
在OS设计中，也可以用它来避免死锁。
为实现银行家算法，每个新进程在进入系统时它必须申明在运行过程中，可能需要的每种资源类型的最大单元数目，其数目不应超过系统所拥有的资源总量。
计算机操作系统银行家算法实验报告
计算机操作系统实验报告一、实验名称:银行家算法二、实验目得:银行家算法就是避免死锁得一种重要方法,通过编写一个简单得银行家算法程序,加深了解有关资源申请、避免死锁等概念，并体会与了解死锁与避免死锁得具体实施方法。
三、问题分析与设计：1、算法思路:先对用户提出得请求进行合法性检查，即检查请求就是否大于需要得，就是否大于可利用得.若请求合法，则进行预分配,对分配后得状态调用安全性算法进行检查。
若安全,则分配；若不安全，则拒绝申请，恢复到原来得状态,拒绝申请。
2、银行家算法步骤:（1）如果Ｒequｅsｔi＜or＝Need,则转向步骤（2）；否则，认为出错，因为它所需要得资源数已超过它所宣布得最大值。
(2）如果Ｒequest〈or＝Available，则转向步骤（3）；否则，表示系统中尚无足够得资源，进程必须等待。
（3）系统试探把要求得资源分配给进程Pｉ,并修改下面数据结构中得数值：Ａvailablｅ=Aｖａilabｌｅ—Requｅst［i]；Allｏcatiｏn＝Ａｌlocatiｏn＋Ｒeｑuest;Nｅed=Need-Rｅquest;（4)系统执行安全性算法，检查此次资源分配后,系统就是否处于安全状态。
３、安全性算法步骤：(１）设置两个向量①工作向量Work。
它表示系统可提供进程继续运行所需要得各类资源数目,执行安全算法开始时,Work=Ａllｏcａtion；②布尔向量Fｉnisｈ。
它表示系统就是否有足够得资源分配给进程，使之运行完成，开始时先做Fｉｎiｓh[ｉ]=ｆalse,当有足够资源分配给进程时，令Finisｈ［i]＝true。
(2)从进程集合中找到一个能满足下述条件得进程:①Ｆiniｓh［i］=ｆalｓe②Need＜or=Work如找到，执行步骤(3)；否则，执行步骤（4）。
(３)当进程P获得资源后,可顺利执行，直至完成，并释放出分配给它得资源,故应执行：Worｋ=Wｏrk+Alｌｏcation;Finish[i]＝truｅ；转向步骤（2).(4)如果所有进程得Fｉniｓh［i]=truｅ,则表示系统处于安全状态;否则,系统处于不安全状态.四、程序源代码:#includｅ〈ｓｔdio、h＞#definｅ W 5/／最大进程数Ｗ=5#deｆine R 3//最大资源总数＝3int Avａｉｌａbｌｅ［3］；／/可利用资源向量iｎt Maｘ［5]［3］;//最大需求矩阵ｉnt Ａlloｃａtion［5］[３］； //分配矩阵ｉｎｔNｅed[5][3];／/需求矩阵iｎt Ｒequeｓt[3］;//进程请求向量ｖoｉd dｉｓpose（）｛prｉntf(”请输入可利用资源向量Avaiｌaｂle(格式:a，b，ｃ)\ｎ”）;sｃａnｆ（＂％d，%d，%d”,&Available［０］，&Avａilablｅ［1],＆Availaｂle[2］）;prｉnｔf（”请输入最大需求数Max（格式:a，b,c）\n"）；ｆor（iｎt j=0;ｊ<5；j++）｛prｉntf("进程%ｄ：\n”，j）；ﻩｓｃａnf(＂%d，％d，％d"，＆Mａx［j]［0］，&Mａx［j］[1］，&Mａｘ［j］［2］）；}priｎtf（"请输入分配数Allocａtion（格式:a，b，c）＼n");for(j＝０;j〈5；ｊ++）{prｉnｔf（＂进程％d\ｎ”,j）;scanf（”%d，％d，％d",&Ａllocaｔion[j］[0］,＆Allocati ｏn[j］[1］,＆Ａlloｃａtｉｏｎ[ｊ］[2］）;}/／输入Max［5］［3］,Ａvａilable［5］[3］,Ａlｌocaｔiｏｎ[5］［3］foｒ(j＝0；j〈5；ｊ+＋)ｆｏr(int i=0；i〈３；i++）Nｅeｄ［j]［ｉ]=Max［j］［i］—Alloｃatｉｏｎ[j］[i］；//求出Ｎeeｄ［5][3］}mａin（）{ﻩprinｔｆ（”银行家算法 \ｎ"）;dispoｓe(）；pｒintf（"安全性检查\n"）;ｉnｔ Wｏrｋ[３］;//系统可提供进程继续运行所需得各类资源数char Fｉｎish［5］;/／表示系统就是否有足够得资源分配fｏr(int i=0；ｉ<5;i＋+)Fiｎish［i]='f'；for（iｎｔｋ=0;k＜３；ｋ+＋）Work[k］=Aｖaiｌable［k］；ｉnｔ q［5］；fｏｒ(int x＝0；x〈50；x+＋)｛prinｔf（”请输入一个序列：＼n”）；ｓcaｎf（"％ｄ,％d，％d,%d，％d",＆ｑ[０],&ｑ[1],＆ｑ［2]，＆q[3］,＆q［４］)；for（ｉ=0；i<5；i＋+)｛if(（Need[q［ｉ]］［０］〈=Woｒk［0］)&＆（Need［q[i］]［1]〈=Wｏrk[1］)＆&（Ｎeeｄ［ｑ［i］][2］＜=Woｒk[２］))//比较Ｎeed[i]［j]与Ｗoｒk［j]{ﻩ fｏr(ｋ=０;ｋ＜3；k＋＋）Woｒk［k］=Woｒk[k］+Alloｃaｔiｏn[q[i］]［k];ﻩ Fiｎｉsｈ[ｉ］＝＇t'；ﻩ}｝ｉf（(Finish［0］==＇ｔ’)&&(Fiｎish[１]==’t＇）&＆(Fin ｉｓｈ［2]=＝＇ｔ＇)＆＆（Fiｎiｓh［3］=＝'ｔ＇）＆＆（Fin ｉｓh［4］＝=＇t＇）)/／通过Ｆinisｈ［i］判断系统就是否安全ﻩｂｒeak;elseﻩprintｆ（＂此序列不就是安全序列,请重新输入一个序列!\ｎ"）；ﻩiｆ(x==49）ﻩrｅtｕrｎ 0;}prinｔf（＂这个系统安全！\n"）；int a；priｎtf("请输入Reqｕeｓｔ进程:＼n”)；scanｆ（”％ｄ”，＆a)；priｎtf("该进程Ｒeｑuｅst（a,ｂ,c）\ｎ＂)；ｓcａｎf（＂％d,%ｄ,％ｄ"，＆Requｅst［0］，＆Rｅquｅｓｔ[1]，＆Ｒeｑuｅsｔ［2］);/／输入请求量Requｅｓt［3]if（（Ｒequest［０］<=Neeｄ［ａ］［０］）&&（Request[１］<=Ｎeeｄ[a］[1]）&＆(Reqｕeｓt［2]〈＝Ｎeｅｄ[a］[２]））//判断Ｒｅｑuｅｓt[i］<=Need［ａ]［i]{if(（Request[0]＜=Neｅｄ[a］[0］）&＆(Ｒeqｕｅsｔ[0]<=Ｎeeｄ[a][1］)&＆(Rｅquｅst[0］〈=Neｅd[a］［２］））／/判断Ｒｅquest[i］<=Avａilable［ａ］［i]ﻩ{ﻩfor（iｎｔ k=0；k<3;k＋＋)｛ﻩＡvａilａｂle[k]＝Avaｉlable[k]—Request[k］；ﻩAlloｃatioｎ[ａ][k］=Alｌocaｔion［ａ］［ｋ］+Ｒeques ｔ［ｋ]；ﻩNeed[a］[k］=Need［a］［k]—Rｅquest[ｋ］;ﻩﻩﻩ//如果上述判断成功，则修改相应得Availaｂle［k］，Allocation ［a］［ｋ］，Ｎeed[ａ］[k］ﻩﻩ｝ﻩpｒintｆ（"资源分配成功!\n”）;ﻩ｝ﻩelｓe{ﻩｐｒiｎtf（”资源分配失败！\n＂)；rｅｔurn 0；ﻩ}｝else{pｒｉntf（"资源分配失败！\ｎ"）；ﻩreturn ０；}}程序截图:五、实验总结多个进程同时运行时，系统根据各类系统资源得最大需求与各类系统得剩余资源为进程安排安全序列，使得系统能快速且安全地运行进程，不至发生死锁。
操作系统银行家算法实验报告
实验五银行家算法一、实验目的和要求①理解死锁概念，银行家算法及安全检测算法。
②在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个。
银行家算法操作系统实验报告
竭诚为您提供优质文档/双击可除银行家算法操作系统实验报告篇一：计算机操作系统银行家算法实验报告计算机操作系统实验报告一、实验名称：银行家算法二、实验目的：银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计：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）。
操作系统_银行家算法报告
实验四：银行家算法的实现一．实验目的（1）加深了解有关资源申请、避免死锁等概念。
（2）体会和了解死锁和避免死锁的具体实施方法。
二．实验属性该实验为设计性实验。
三．实验仪器设备及器材普通PC386以上微机四．实验要求本实验要求2学时完成。
本实验要求完成如下任务：（1）设计进程对各类资源最大申请表示及初值的确定。
（2）设定系统提供资源的初始状况。
（3）设定每次某个进程对各类资源的申请表示。
（4）编制程序，依据银行家算法，决定其资源申请是否得到满足。
（5）显示资源申请和分配时的变化情况。
五、实验设计及其思路数据结构：Available[m] 用来表示可利用资源的数目初始值是该类全部可用资源的数目。
MAX[n][m] 用来定义n个进程中的每一个进程对m类资源的最大需求Allocation[i][j] 用来表示i个进程中的每一个进程对j类资源已经拥有的数值Need[i][j] 用来表示i个进程中的每一个进程对j类资源还需要的数值在此程序中通过输入输出流从txt文档中读取数据进入以上数据数组中通过控控制台向request[i][j]数组输入值 此数组用来表示进程i 向j 资源请求申请资源个数 银行家算法流程图开始进程发出资源请求（request ）所需要资源小于目前最大值Request<=need所需要资源小于可利用值Request<=avilable把资源分配给此进程并改变相关数值安全性算法 返回值是Y否出错（该系统无法执行此类进程）该进程暂时无法获得此资源 需等待还原相关数据是否分配成功结束是是否安全性算法流程图六 输出结果向其中输入三组数据1 p1发出请求向量request （1,0,2） 正确结果为分配资源2 p4发出请求向量request （3,3,0） 正确结果会产生安全问题要等待3 p0发出请求向量request （0,2，0）正确结果产生安全隐患需等待开始定义可以用的资源数目work 还有是否能在有限的资源条件下完成线程的标志finish ，并给他们所有的线程都可以顺利完成count 等于进程总数 尽可能多的找到满足（finish==false 和need<=work 这两个条件的线程）并对资源做相应的更改更改次数用count 计录 返回 N返回Y 结束是 否七、代码#include<iostream.h>#include<fstream.h>#include<stdio.h>int *avilable;//表示现在可利用的各类资源的数目int **max1;//用二维数组存储各给线程最多能够申请到个资源的数目int **allocation;//用二维数组存储目前各个线程已占用各类资源的数量int **need;//用二维数组存储目前每个进程还需要各类资源的数量方能完成工作int*xiancheng;//用来存储安全序列int m,n;//m用来记录资源的总数，n用来计算进程的总数void show();//用来向控制台输出allocation，needmax1，avilable的数据int correct();//安全性算法void createavilable();//为目前可利用资源赋初值void createmax();//为每一个进程对各类资源的最大需求赋初值void createallocation();//为目前各个进程已经申请到的资源赋初值void createneed();//为完成该进程所需要的各类资源数量赋初值int banker();//银行家算法int main(){ int choice=1;createavilable();createmax();createallocation();createneed();while(choice!=0){banker();cout<<"请输入你的选择（1继续，2重来 0 退出）"<<endl;cin>>choice;if(choice==1) show();if(choice==2){createavilable();createmax();createallocation();createneed(); }}return 0;}void createavilable(){ifstream inFile;int i;i=0;inFile.open("avilable.txt");//从txt文件中读取数据为其赋值inFile>>m;inFile.get();avilable=new int[m];cout<<"avilable:"<<endl;cout<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;while(inFile){inFile>>avilable[i];cout<<avilable[i]<<'\t';//显示到控制台上char c;inFile.get(c);//用来准确定读取时位真正的结束位置i++;}cout<<endl;}void createmax(){ifstream inFile1;inFile1.open("max.txt");inFile1>>n;inFile1.get();max1=new int*[n];//实现为二维数组动态分配内存for(int k=0;k<n;k++)max1[k]=new int[m];cout<<"max:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for(int i=0;i<n;i++){ cout<<"p"<<i<<'\t';for(int j=0;j<m;j++){ if(inFile1) inFile1>>max1[i][j];cout<<max1[i][j]<<'\t';}cout<<endl;}}void createallocation(){ifstream inFile1;inFile1.open("allocation.txt");allocation=new int*[n];for(int k=0;k<n;k++)allocation[k]=new int[m];cout<<"allocation:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for(int i=0;i<n;i++){ cout<<"p"<<i<<'\t';for(int j=0;j<m;j++){ if(inFile1) inFile1>>allocation[i][j]; cout<<allocation[i][j]<<'\t';}cout<<endl;}}void createneed(){need=new int*[n];for(int k=0;k<n;k++)need[k]=new int[m];cout<<"need:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for(int i=0;i<n;i++){ cout<<"p"<<i<<'\t';for(int j=0;j<m;j++){ need[i][j]=max1[i][j]-allocation[i][j];//根据max allocation和need的关系为need赋值cout<<need[i][j]<<'\t';}cout<<endl;}}int correct(){int *work;//工作向量bool *finish,flag;//finish用来表示进程是否可以在特定的资源下完成工作，flag用来标记循环是否结束int i, k,count1,count;work=new int[m];xiancheng=new int[m];for( i=0;i<m;i++)work[i]=avilable[i];finish=new bool[n];//初值都为falsefor(k=0;k<n;k++)finish[k]=false;count=0;do{for(i=0;i<n;i++){flag=false;count1=0;for(k=0;k<m;k++)if(need[i][k]<=work[k]) count1++;//判断i个进程对各类资源的需要是小于该类资源的工作数量并记录小于的个数else break;if(count1==m&&finish[i]==false)//判断对每类资源来说都是所需小于工作数量并且该类线程并没有完成任务{ for(k=0;k<m;k++){work[k]=work[k]+allocation[i][k];finish[i]=true;flag=true;}xiancheng[count]=i;count++;}}}while(flag==true);//可能多的找到满足（finish==false和need<=work 这两个条件的线程）并对资源做相应的更改更改次数用count计录cout<<count<<endl;if(count==n)return 1;elsereturn 0;}int banker(){int *request,i,j,count;request=new int[m];//资源请求i=count=0;cout<<"哪个进程请求资源"<<endl;cin>>j;cout<<"请依次输入a，b,c资源的请求数"<<endl;while(i<m) {cin>>request[i]; i++;}for(i=0;i<m;i++)if(request[i]<=need[j][i]) count++;else break;if(count!=m) //判断所需要资源小于目前最大值Request<=need {cout<<"此操系统不能完成这个进程"<<endl;return 0;}count=0;for(i=0;i<m;i++)if(request[i]<=avilable[i]) count++;else break;if(count!=m)//所需要资源小于可利用值Request<=avilable {cout<<"现在可利用资源不能满足需要，需要等候"<<endl; return 0;}for(i=0;i<m;i++){avilable[i]=avilable[i]-request[i];allocation[j][i]=allocation[j][i]+request[i];need[j][i]=need[j][i]-request[i];}if(correct()==1)//安全性算法{cout<<"可以将资源分配给"<<"p"<<j<<"进程，其中安全序列可以是："<<endl;for(i=0;i<n;i++)cout<<"p"<<xiancheng[i]<<'\t';cout<<endl;}else{cout<<"因为会造成系统不安全，所以不分配资源给"<<"p"<<j<<"进程"<<endl;for(i=0;i<m;i++){avilable[i]=avilable[i]+request[i];allocation[j][i]=allocation[j][i]-request[i];need[j][i]=need[j][i]+request[i];}}return 0;}void show(){ int i,j;cout<<"avilable:"<<endl;cout<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for( i=0;i<m;i++)cout<<avilable[i]<<'\t';cout<<endl;cout<<"max:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl;for( i=0;i<n;i++){ cout<<"p"<<i<<'\t';for( j=0;j<m;j++){cout<<max1[i][j]<<'\t';}cout<<endl;}cout<<"allocation:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl; for(i=0;i<n;i++){ cout<<"p"<<i<<'\t'; for( j=0;j<m;j++){cout<<allocation[i][j]<<'\t';}cout<<endl;}cout<<"need:"<<endl;cout<<'\t'<<"a"<<'\t'<<"b"<<'\t'<<"c"<<endl; for( i=0;i<n;i++){cout<<"p"<<i<<'\t';for( j=0;j<m;j++){cout<<need[i][j]<<'\t';}cout<<endl;}}。
操作系统银行家算法实验报告_(1)
银行家算法实验报告【实验目的】（1）根据设计题目的要求，充分地分析和理解题目，叙述系统的要求，明确程序要求实现的功能以及限制条件。
（2）明白自己需要用代码实现的功能，清楚编写每部分代码的目的，做到有的放矢，有条理不遗漏的用代码实现银行家算法。
【实验要求】（1）了解和理解死锁；（2）理解利用银行家算法避免死锁的原理；（3）会使用某种编程语言。
【实验原理】一、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列)，为每个进程分配所需的资源，直至最大需求，使得每个进程都能顺利完成。
二、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后，表示为Requesti[j]=k。
系统按下述步骤进行安全检查：（1）如果Request i≤Need i则继续以下检查，否则显示需求申请超出最大需求值的错误。
（2）如果Request i≤Available则继续以下检查，否则显示系统无足够资源，Pi阻塞等待。
（3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：Available［j］∶=Available［j］-Request i[j］;Allocation［i,j］∶=Allocation［i,j］+Request i［j］;Need［i,j］∶=Need［i,j］-Requesti［j］;（4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。
若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
三、安全性算法（1）设置两个向量：①工作向量Work: 它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work∶=Available;② Finish: 它表示系统是否有足够的资源分配给进程，使之运行完成。
开始时先做Finish［i］∶=false; 当有足够资源分配给进程时，再令Finish ［i］∶=true。
银行家算法 实验报告
淮海工学院计算机工程学院实验报告书课程名：《操作系统原理》题目：银行家算法班级：学号：姓名：一、实验目的银行家算法是操作系统中避免死锁的典型算法，本实验可以加深对银行家算法的步骤和相关数据结构用法的更好理解。
实验环境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*/。
银行家算法 实验报告
淮海工学院计算机工程学院实验报告书课程名：《操作系统原理》题目：银行家算法班级： D学号：姓名：一、实验目的银行家算法是操作系统中避免死锁的典型算法，本实验可以加深对银行家算法的步骤和相关数据结构用法的更好理解。
实验环境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．银行家算法的局限性有哪些？银行家算法是一种最有代表性的避免死锁的算法。
银行家算法即把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。
实验报告_银行家算法
1. 题目分析1.1 设计目的●理解死锁产生的原因和必要条件●了解避免死锁的几种基本方法●掌握银行家算法及安全性算法1.2 设计内容设计内容包括银行家算法和安全性算法，以及用VC界面实现输出1.3 相关知识概述银行家算法是一种最有代表性的避免死锁的算法。
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。
安全状态一定是没有死锁发生。
不安全状态:不存在一个安全序列。
不安全状态一定导致死锁。
安全序列：一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
2. 概要设计2.1主要数据结构描述static int MAX[5][3]; //最大需求矩阵static int AVAILABLE[3]; //可利用资源矩阵static int ALLOCATION[5][3]; //分配矩阵static int NEED[5][3]; //需求矩阵因为数组成员MAX,AVAILABLE, ALLOCATION, NEED的值每次调用一次银行家算法，如果分配成功，都会改变，所以将他们设定为静态成员变量。
int Request[3]; //请求向量int Work[3]; //工作向量bool FINISH[5];//标记系统是否有足够的资源分配给进程2.2 流程图（1）银行家算法流程图单击“执行银行家算法”按钮时会调用OnButton1()函数，相当于银行家算法注：只要不按“退出”按钮退出程序，数组MAX,A V AILABLE, ALLOCATION, NEED中会保留上一次执行完后变化的值，不停的单击“进行银行家算法”按钮，程序会在上一次执行完后的基础上反复的执行银行家算法。
（2）安全性算法流程图3. 详细设计3.1 主要算法描述当进程pi提出资源申请时，系统执行下列步骤：（1）若Request≤Need,转（2）；否则错误返回（2）若Request≤Available,转（3）；否则进程等待(3）假设系统分配了资源，则有：Available:=Available-Request;Allocation:=Allocation+Request;Need:=Need-Request若系统新状态是安全的，则分配完成若系统新状态是不安全的，则恢复原状态，进程等待安全性检查的步骤：(1) Work:=Available;Finish:=false;(2) 寻找满足条件的i：Finish=false;Need≤Work;如果不存在，则转(4)(3) Work:=Work+Allocation;Finish:=true;转(2)(4) 若对所有i,Finish=true,则系统处于安全状态，否则处于不安全状态3.2 程序界面设计4. 编码实现4.1 开发工具简介Visual C++集成开发环境下下实现的4.2 部分程序源码int CSisuoDlg::MAX[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};int CSisuoDlg::AVAILABLE[3]={3,3,2};int CSisuoDlg::ALLOCATION[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}}; int CSisuoDlg::NEED[5][3]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};int CSisuoDlg::safe(){int i,j,k,l=0;int Work[3];bool FINISH[5];int p[5];for(i=0;i<3;i++)Work[i]=AVAILABLE[i];for(i=0;i<5;i++){ FINISH[i]=false;}for(i=0;i<5;i++){if(FINISH[i]==true){ continue;}else{for(j=0;j<3;j++){if(NEED[i][j]>Work[j]){break;}}if(j==3)//找到满足要求的进程{FINISH[i]=true;for(k=0;k<3;k++){Work[k]+=ALLOCATION[i][k];}p[l++]=i;//记录安全序列i=-1;//每次都是从头开始找}else{continue;}}if(l==5){show+="经安全性检查,系统安全,本次分配成功。
操作系统实验银行家算法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(); //调用银行家算法函数}。
实验三银行家算法实验报告
实验三银行家算法实验报告一、实验目的银行家算法是一种用于避免死锁的算法，本次实验旨在通过编程实现银行家算法，并通过模拟银行家算法的运行过程来加深对该算法的理解。
二、实验过程及结果1. 系统设计为了模拟银行家算法的运行过程，需要设计一个包含多个进程和资源的系统。
每个进程都有一定的最大需求资源数和已分配资源数。
系统中还有一定数量的可用资源，进程可以请求资源和释放资源。
2. 算法实现在程序中实现银行家算法需要以下几个关键的函数：（1）银行家算法的主函数：实现进程的请求资源和释放资源操作，并在此过程中判断是否产生死锁；（2）安全检查函数：用于判断系统状态是否安全，即是否存在一个安全序列，如果存在则表示系统处于安全状态，否则表示系统处于不安全状态；（3）资源请求函数：用于进程请求资源的操作，根据银行家算法的要求进行判断；（4）资源释放函数：用于进程释放资源的操作。
3. 算法运行通过对编写的程序进行多次运行测试，模拟不同进程对资源的请求和释放，观察系统是否能够始终处于安全状态。
在每次运行中，记录并输出系统的安全序列和进程的状态等信息。
4. 实验结果分析通过实验运行结果的分析，可以得出以下结论：（1）银行家算法能够有效地避免死锁的发生；（2）系统中资源的分配和释放过程需要合理，否则可能导致系统陷入死锁；（3）资源的分配策略对系统的安全状态有重要影响。
三、实验总结通过本次实验，深入了解了银行家算法的原理和实现过程，并通过编程实践加深了对该算法的理解。
银行家算法是一种重要的死锁避免算法，能够保证系统处于安全状态下运行，并且能够合理地分配系统资源，避免系统陷入死锁。
四、参考文献[1] 《操作系统概念》,Abraham Silberschatz，Peter B. Galvin，Greg Gagne，电子工业出版社，2014年五、附录（示例代码省略）以上是本次实验的实验报告，通过实验我们深入了解了银行家算法，了解了它在操作系统中的应用和重要性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Allocation[i][j]= Allocation[i][j]+ Request [j]；
need[i][j]= need[i][j]- Request [j]；
(4)试分配后，执行安全性检查，调用 check()函数检查此次资源
分配后系统是否处于安全状态。若安全，才正式将资源分配给进
程；否则本次试探分配作废，恢复原来的资源分配状态，让该进 程等待。 (5)用 do{…}while 循环语句实现输入字符 y/n 判断是否继续进行 资源申请。
实验报告
题目 名称
C 语言实现银行家算法
院 系 信息科学与工程 班 级 学院
完成时间
指导老师
组长
联系电话 组员（姓名，
学号） 组员（姓名，
学号） 组员（姓名，
学号） 组员（姓名，
本次实验 成绩
邮件地址 @qq/com
主要任务 程序算法的编写、实现、运行调试
主要任务 实验报告的完成
主要任务 实验报告的完成
体
因为他所需要的资源数已经超过它所宣布的最大值。
实
验
(2)如果：Request i[j]<=available[i,j]，转向步骤(3)，否则
步
表示尚无足够资源，进程 i 需等待。
骤
(3)若以上两个条件都满足，则系统试探着将资源分配给申请的进
程，并修改下面数据结构中的数值：
Available[i,j]= Available[i,j]- Request [j]；
实
的编程能力得到了较大提高，希望能有更多这样的机会，借此较
好的锻炼自己，从而更好的掌握和运用自己的专业知识，提高能
验
力水平。
心 本次实验相对于 c 基础并不好的我有一定的难度，所以我在程序方面
得
所做的较少。而对银行家算法了解的比较透彻，在程序设计的原理和流程
图方面做的工作较多，本次实验我学到的东西好多，也知道自己在很多方
考
(2) 顾客可以分期贷款,但贷款的总数不能超过最大需求
的
量;
资
(3) 当银行家现有的资金不能满足顾客尚需的贷款数额
料
（
时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里
包
得到贷款;
括
(4) 当顾客得到所需的全部资金后,一定能在有限的时间
实
里归还所有的资金.
验
操作系统按照银行家制定的规则为进程分配资源，当进程
面的不足，虽然我给自己的发展方向定位为硬件方向，但是对 C 语言还是
要进一步的学习。
附录 1 银行家算法流程图
系统初始化
输入进程个数 no1
输入资源类数 no2
输 入 进 程 最 大 需 求 矩 阵 Max 、 已 分 配 矩 阵 Allocation 和可利用资源矩阵 Available
Need[][]=Max[][]-Allocation[][]
二．安全性检查算法（check()函数）
主
(1)设置两个向量：
要
工作向量 Work，它表示系统可提供给进程继续运行所需的各类资
算
法
源数目，在执行安全性算法开始时，Work= Available。
流
工作向量 Finish，它表示系统是否有足够的资源分配给进程，使
程
图
之运行完成。开始时先做 Finish[i]=false；当有足够的资源分配
和
给进程时，再令 Finish[i]=true。
具
体
实
(2)在进程中查找符合以下条件的进程：
验
步
条件 1：Finish[i]=false；
骤
条件 2：need[i][j]<=Work[j]
若找到，则执行步骤(3)否则，执行步骤(4)
(3)当进程获得资源后，可顺利执行，直至完成，并释放出分配给 它的资源，故应执行： Work[j]= Work[j]+ Allocation[i][j]； Finish[i]=true； goto step (2)；
(4)如果所有的 Finish[i]=true 都满足，则表示系统处于安全状 态，否则，处于不安全状态。
附录 3 -- 程序源代码
程序源代码及
调试结果 附录 4 -- 程序运行调试结果
本次实验我负责程序的编写方面，虽然基础一般，但是我仍
然坚持花了三天的时间终于把程序拿下，这是让自己很欣慰的事，
本次实验不仅让我对银行家算法有了更深入的理பைடு நூலகம்，并且还让我
调用 check()函数
work[]=available[] finish[]=false
N
need[][]<=work[] finish[]=false ?
Y
work[]=work[]+allocation[][] finish[]=true
所有进程的 finish[]==true?
Y
输出安全序列，并打印 出当前资源分配情况
N 输出提示：系统不安全
调用结束
附录 3
程序源代码：
#include <stdio.h> #include <stdlib.h> #include <conio.h> # define m 50
主要参考书：
计算机操作系统第三版
算法流程图：
西安电子科技大学出版社
汤子瀛主编
附录 1 -- 银行家算法流程图
附录 2 -- 安全性算法流程图
主
要 算
实验步骤：
法
流 程
一．银行家算法
图
进程 i 发出请求资源申请，
和
具
(1)如果 Request [j]<=need[i,j],转向步骤(2),否则认为出错，
打印输出此时资源分配情况表
输入欲申请资源进程号
输入是否合法 Y
输入该进程申请的资源量
Request[]>Need[][]? N
Request[]>Available[][]? N 预分配
调用 check()函数进行安全性检查 退出系统
N Y
Y Y
继续分配(Y)? or
退出(N)?
N
附录 2 安全性算法流程图
内
首次申请资源时，要测试该进程对资源的最大需求量，如果系
容
统现存的资源可以满足它的最大需求量则按当前的申请量分
及
配资源，否则就推迟分配。当进程在执行中继续申请资源时，
条
先测试该进程本次申请的资源数是否超过了该资源所剩余的
件
总量。若超过则拒绝分配资源，若能满足则按当前的申请量分
）
配资源，否则也要推迟分配。
学号）
银行家算法原理：
主
我 们 可 以 把 操 作 系 统 看 作 是 银 行 家 ，操 作 系 统 管 理 的 资 源
要
相当于银行家管理的资金，进程向操作系统请求分配资源相当
原
于用户向银行家贷款。
理
及
为保证资金的安全,银行家规定:
所
(1) 当一个顾客对资金的最大需求量不超过银行家现有
参
的资金时就可接纳该顾客;