银行家算法的模拟实现—实验报告
银行家算法实验报告总结
银行家算法实验报告总结一、实验目的与背景银行家算法是一种用于避免死锁和保证系统稳定运行的算法。
通过模拟银行贷款行为的策略，银行家算法可以有效地避免系统的资源枯竭，从而保证系统的正常运行。
在本实验中，我们通过使用银行家算法对实际的系统进行模拟，验证其有效性。
二、算法原理与流程银行家算法的主要原理是：将系统中的所有资源按照类型进行分类，并对每种资源设置一个最大值和最小值，分别表示该资源的最大需求量和最小剩余量。
同时，对于每个进程，需要定义其最大需求量、已分配资源和需求量，并根据这些信息来决定是否分配资源。
具体流程如下：初始化：将所有资源的最大值和最小值进行初始化，并给每个进程分配一个唯一的标识符。
请求资源：每个进程在执行过程中，如果需要更多的资源，则向系统发送请求。
分配资源：系统根据银行家算法的原理，将资源分配给满足条件的进程。
更新资源：系统更新已分配给进程的资源，并检查是否满足每个进程的最大需求量。
重复执行：如果存在多个进程需要资源，则重复执行步骤2-4，直到所有进程都满足其最大需求量或系统中的资源不足以为更多的进程分配资源为止。
三、实验数据与结果在本实验中，我们使用了10个进程，每个进程的需求量和已分配资源均随机生成。
实验结果表明，在满足了每个进程的最大需求量后，系统中仍有剩余资源，证明了银行家算法可以有效地避免资源的浪费。
四、结果分析通过对实验结果进行分析，我们发现银行家算法可以有效地保证系统的稳定性，避免出现死锁和资源枯竭等问题。
同时，该算法需要较少的系统开销，因为只需要对每个进程的请求进行处理和更新，不需要进行额外的检查和管理。
五、性能对比分析为了进一步验证银行家算法的性能，我们将其与其他常见的资源管理算法进行了比较。
在同等条件下，与其他算法相比，银行家算法具有更高的系统吞吐量和更低的响应时间。
银行家算法在系统吞吐量和响应时间方面均优于其他常见算法，而在死锁发生率上，银行家算法则表现出了更高的稳定性。
银行家算法实验报告
银行家算法实验报告银行家算法实验报告引言：在计算机科学领域中，银行家算法是一种用于避免死锁的资源分配算法。
它是由荷兰计算机科学家艾兹赫尔·迪科斯彻在1965年提出的。
银行家算法通过合理的资源分配和安全性检查，确保系统中的进程能够安全地执行，避免了资源竞争和死锁的发生。
本篇文章将详细介绍银行家算法的原理、实验设计和结果分析。
一、银行家算法的原理银行家算法基于资源的最大需求和可用性进行资源分配。
它将系统中的资源分为若干类别，并为每个类别分配一个初始数量。
当进程请求资源时，银行家算法会检查该请求是否能够满足，如果满足则分配资源，否则将进程置于等待状态。
算法的核心思想是避免分配资源后导致系统无法满足其他进程的资源需求，从而避免死锁的发生。
二、实验设计为了验证银行家算法的有效性，我们设计了一个模拟实验。
实验中，我们创建了一个包含多个进程和资源的系统，并模拟了进程对资源的请求和释放。
每个进程都有自己的资源需求和最大需求量，系统中的资源总量也是有限的。
首先，我们初始化系统的资源数量和每个进程的最大需求量。
然后，模拟进程的请求和释放过程。
当一个进程请求资源时，银行家算法会检查该请求是否能够满足，如果满足则分配资源，否则将进程置于等待状态。
当一个进程释放资源时，系统将回收该资源并重新分配给其他进程。
实验的关键是设计合理的资源分配策略和进程请求顺序，以模拟不同的场景。
我们通过调整进程的最大需求量和资源数量，观察系统的运行情况和死锁的发生情况。
三、实验结果分析通过多次实验，我们得出了以下结论：1. 资源数量的合理分配对避免死锁非常重要。
如果资源数量过少，无法满足进程的最大需求量，系统容易发生死锁。
如果资源数量过多，系统的资源利用率低，效率低下。
因此，需要根据系统的实际需求合理分配资源数量。
2. 进程的最大需求量与资源数量的关系也是影响死锁的重要因素。
当进程的最大需求量超过系统资源数量的一半时，系统容易发生死锁。
民大-银行家算法-操作系统实验报告
银行家算法实验报告一、实验题目为了了解系统的资源分配情况，假定系统的任何一种资源在任一种资源在任意时刻只能被一个进程使用。
任何进程已经占用的资源只能由进程自己释放，而不能任由其他进程抢占。
当进程申请的资源不能满足时，必须等待。
因此，只要资源分配算法能保证进程的资源请求，且不出现循环等待，则系统不会出现死锁。
而银行家算法是避免死锁的一种重要方法。
通过编写一个模拟动态资源分配的银行家算法程序，进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法二、实验要求要求编写系统进行资源调度的程序，模拟进程的资源分配算法，了解死锁的产生和避免的办法。
一个是随机动态地进行资源分配的模拟程序，即只要系统当前剩余资源满足进程的当前要求，就立即将资源分配给进程，以观察死锁产生情况；一个是采用银行家算法，有效地避免死锁的产生。
要求用银行家算法和随机算法实现资源分配。
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获得所申请资源七、总结这次实验中我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
银行家算法的模拟实现
{cout << p[i];
if (i != l - 1)
{ cout << "-->";
}
} cout << "" << endl;
return true;
}
实验模拟结果：
总
结
银行结算法有效避免了系统在资源分配中的死锁问题。通过至此实验更是加深了对这一方面的理解与认识，对系统进程分配资源的过程和实现该过程的算法结构认识更加深刻。
{ if (FINISH[i] == true)
{ continue;
}for (j = 0; j < n; j++)//循环查找第i个进程需要的各个资源数是否超过系统现有的对应的资源数
}
if (NEED[i][j] > Work[j])//第i个进程需要的第j个资源数＞系统现有的第j个资源数
{ break ;
goto input;
}
} for (i = 0; i < n; i++)//如果请求合理，那么下面
{ AVAILABLE[i] -= REQUEST[cusneed][i];//系统可用资源减去申请了的
ALLOCATION[cusneed][i] += REQUEST[cusneed][i];//线程被分配的资源加上已申请了的
Work[i] = AVAILABLE[i];
for (i = 0; i < m; i++)
{ FINISH[i] = false;//FINISH记录每个进程是否安全
银行家算法实验报告13551
操作系统实验报告课题：银行家算法专业：班级：学号：姓名：年月日目录一实验目的……………………………………………………错误!未定义书签。
二实验容 (3)三问题描述 (3)四设计思路 (4)五详细设计 (5)六运行结果 (10)七心得体会 (16)八参考文献 (17)附源程序 (17)一、实验目的模拟实现银行家算法，用银行家算法实现资源分配。
1．加深了解有关资源申请、避免死锁等概念。
2．体会和了解死锁和避免死锁的具体实施方法。
3、输入：1.系统中各类资源表2.每个进程需要各类资源总数系统分配给各个进程各类资源数4、输出：1.判断T0时刻的安全性2.如果系统是安全的，任意给出某个进程的一个资源请求方式并判断系统能否接受此请求，如果可以接受，其输出全部安全序列，反之，不予分配。
二、实验容1．设计进程对各类资源最大申请表示及初值的确定。
2．设定系统提供资源的初始状况。
3．设定每次某个进程对各类资源的申请表示。
4．编制程序，依据银行家算法，决定其资源申请是否得到满足。
5．显示资源申请和分配时的变化情况。
三、问题描述银行家算法.顾名思义是来源于银行的借贷业务，一定数量的本金要应多个客户的借贷周转，为了防止银行加资金无法周转而倒闭，对每一笔贷款，必须考察其是否能限期归还。
在操作系统中研究资源分配策略时也有类似问题，系统中有限的资源要供多个进程使用，必须保证得到的资源的进程能在有限的时间归还资源，以供其他进程使用资源。
如果资源分配不得到就会发生进程循环等待资源，则进程都无法继续执行下去的死锁现象。
在死锁的避免中，银行家算法把系统状态分为安全状态和不安全状态，只要能使系统始终处于安全状态，便可以避免发生死锁。
所谓安全状态，是指系统能按某种顺序为每个进程分配所需资源，直到最大需求，使每一个进程都可以顺利完成，即可找到一个安全资源分配序列。
模拟实现这个工作过程。
四、设计思路我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。
银行家算法实验报告
计算机操作系统实验报告一、实验名称：银行家算法二、实验目的：银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
三、问题分析与设计：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）。
编程模拟银行家算法实验报告
武汉理工大学华夏学院课程设计报告书课程名称：操作系统原理题目：编程序模拟银行家算法系名：信息工程系专业班级：计应2091姓名：王汝平学号： 10225509118 指导教师:苏永红2011 年 7 月 6 日课程设计任务书学生姓名：王汝平专业班级：计应2091指导教师：苏永红工作单位：信息工程系设计题目：编程序模拟银行家算法初始条件：Linux操作系统，GCC编译环境要求完成的主要任务：主要任务：银行家算法是避免死锁的一种重要方法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。
加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。
思想：将一定数量的资金供多个用户周转使用，当用户对资金的最大申请量不超过现存资金时可接纳一个新客户，客户可以分期借款，但借款总数不能超过最大的申请量。
银行家对客户的借款可以推迟支付，但是能够使客户在有限的时间内得到借款，客户得到所有的借款后能在有限的时间内归还。
用银行家算法分配资源时，测试进程对资源的最大需求量，若现存资源能满足最大需求就满足当前进程的申请，否则推迟分配，这样能够保证至少有一个进程可以得到所需的全部资源而执行到结束，然后归还资源，若OS能保证所有进程在有限的时间内得到所需资源则称系统处于安全状态。
设计报告撰写格式要求：1设计题目与要求 2 设计思想3系统结构 4 数据结构的说明和模块的算法流程图5 使用说明书（即用户手册）：内容包含如何登录、退出、读、写等操作说明6 运行结果和结果分析（其中包括实验的检查结果、程序的运行情况）7 自我评价与总结 8 附录：程序清单，注意加注释（包括关键字、方法、变量等），在每个模块前加注释；时间安排7月 4日布置课程设计任务；分配题目后，查阅资料、准备程序；7月 5 ～7月7 日上机调试程序、书写课程设计报告；7月8 日提交课程设计报告及相关文档。
指导教师签名：2011年7月2日系主任签名：2011年7月3日目录1.需求分析 (4)1.1课程设计题目 (4)1.2课程设计目的 (4)1.3设计任务 (4)1.4设计思想 (4)2.设计思想和过程 (5)2.1 概要设计 (5)2.2程序源代码 (7)3.调试及运行结果 (13)4.实验心得体会 (15)5.参考文献 (15)1.需求分析1.1课程设计题目：编程序模拟银行家算法1.2设计目的1.2.1银行家算法是避免死锁的一种重要方法，本实验要求用级语言编写和调试一个简单的银行家算法程序。
银行家算法实验报告绪论
一、实验背景在计算机系统中，资源分配和死锁问题是操作系统领域的重要研究课题。
在多进程环境下，进程之间会共享系统资源，如CPU、内存、磁盘等。
然而，当多个进程同时申请资源时，可能会出现死锁现象，导致系统瘫痪。
为了避免死锁，研究者提出了多种资源分配算法，其中最具代表性的就是银行家算法。
银行家算法最初由Edsger Dijkstra于1965年提出，旨在解决银行在贷款业务中可能出现的死锁问题。
该算法通过模拟银行家在贷款业务中的决策过程，对资源分配进行动态规划，以确保系统处于安全状态，从而避免死锁的发生。
二、实验目的本次实验旨在通过实现银行家算法，加深对资源分配、死锁和安全性概念的理解，并掌握以下内容：1. 了解资源分配的基本原理和死锁的概念。
2. 掌握银行家算法的原理和实现方法。
3. 能够运用银行家算法对系统资源进行动态分配，并确保系统处于安全状态。
4. 分析实验结果，验证银行家算法的有效性。
三、实验原理1. 资源分配资源分配是指操作系统将资源分配给进程的过程。
在多进程环境下，资源分配策略需要考虑以下因素：（1）资源的类型和数量。
（2）进程对资源的最大需求。
（3）进程当前已分配的资源。
（4）系统可利用的资源。
2. 死锁死锁是指多个进程在执行过程中，因争夺资源而相互等待，导致系统无法继续执行的现象。
产生死锁的必要条件包括：（1）互斥条件：资源不能被多个进程同时占用。
（2）请求和保持条件：进程在等待资源时，仍保持已占有的资源。
（3）不剥夺条件：进程不能被强制剥夺已占有的资源。
（4）循环等待条件：存在一个进程序列，其中每个进程都在等待前一个进程所持有的资源。
3. 安全状态安全状态是指系统可以按照某种顺序为每个进程分配资源，使得所有进程都可以顺利完成的状态。
判断系统是否处于安全状态的方法如下：（1）计算每个进程的最大需求。
（2）计算系统可利用的资源。
（3）从最大需求中减去已分配的资源，得到剩余需求。
（4）判断剩余需求是否小于等于系统可利用的资源。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《银行家算法的模拟实现》 --实验报告题目: 银行家算法的模拟实现专业:班级:组员:指导老师:一、实验目的死锁会引起计算机工作僵死，因此操作系统中必须防止。
本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。
二、实验内容模拟实现银行家算法实现死锁避免。
要求：初始数据（如系统在T0时刻的资源分配情况、每一种资源的总数量）从文本文件读入，文件中给出最大需求矩阵Max、分配矩阵Allocation，在程序中求得需求矩阵Need和可利用资源向量Available。
三、实验分析过程1、整个银行家算法的思路。
先对用户提出的请求进行合法性检查，再进行预分配，利用安全性检查算法进行安全性检查。
1)进程一开始向系统提出最大需求量.?2)进程每次提出新的需求(分期贷款)都统计是否超出它事先提出的最大需求量.?3)若正常,则判断该进程所需剩余剩余量(包括本次申请)是否超出系统所掌握的?剩余资源量,若不超出,则分配,否则等待2、算法用到的主要数据结构和C语言说明。
（1）、可利用资源向量 INT AVAILABLE[M] M为资源的类型。
（2）、最大需求矩阵 INT MAX[N][M] N为进程的数量。
（3）、已分配矩阵 INT ALLOCATION[N][M]（4）、还需求矩阵 INT NEED[N][N]（5）、申请各类资源数量int Request[x]; ."<<endl;cout<<"|-------|------------|-----------|----------|-----------|"<<endl;cout<<"|-------|最大需求矩阵|已分配矩阵-|-需求矩阵-|可利用资源-|"<<endl;cout<<"| 资源 | Max | Allocation| Need | available |"<<endl;cout<<"| | A B C | A B C | A B C | A B C |"<<endl;cout<<"|进程 | | | | |"<<endl;cout<<"|-------|------------|-----------|----------|-----------|"<<endl;for(i=0;i<5;i++){cout<<"| p"<<i<<" | ";for(j=0;j<3;j++) {cout<<max[i][j]<<" "; }cout<<" | ";for(j=0;j<3;j++) {cout<<" "<<allocation[i][j]; }cout<<" | ";for(j=0;j<3;j++) {cout<<" "<<need[i][j]; }cout<<" |";if(i==0) {for(j=0;j<3;j++) {cout<<" "<<available[j]; }cout<<" |"; }if(i>0){cout<<" |"; }cout<<endl; }cout<<"|-------|------------|-----------|----------|-----------|"<<endl; }/*--------试分配函数-------*/void tryfenpei(int i){for(int f=0;f<c;f++){available[f]=available[f]-request[f];allocation[i][f]=allocation[i][f]+request[f];need[i][f]=need[i][f]-request[f];}}/*--------恢复数据函数-------*/void refenpei(int i){for(int f=0;f<c;f++){available[f]=available[f]+request[f];allocation[i][f]=allocation[i][f]-request[f];need[i][f]=need[i][f]+request[f];}}int com(int *p,int *q){int i;for(i=0;i<c;i++)if(p[i]>q[i])return 0;return 1;}/*--------安全检测函数---------*/void checksafe(int s)int flag,temp[t],i,j,l,k=0;bool finish[t];for(i=0;i<t;i++)finish[i]=false;for(j=0;j<c;j++)work[j]=available[j];cout<<"|-------|-----------------|----------|"<<endl;cout<<"| resource |-Work+Allocation-|--Finish--|"<<endl;cout<<"| | A B C | T/F |"<<endl;cout<<"|programme | | |"<<endl;cout<<"|-------|-----------------|----------|"<<endl;for(i=0;i<t;i++){l=0;for(j=0;j<c;j++){if(need[i][j]>work[j])l=1;break;}if(finish[i]==false&&l==0){cout<<"| p"<<i<<" | ";for(j=0;j<c;j++){work[j]=work[j]+allocation[i][j];if(work[j]>9)cout<<" "<<work[j]<<" ";elsecout<<" "<<work[j]<<" ";}cout<<" ";cout<<"|";cout<<" ";finish[i]=true;cout<<"true ";cout<<"|";temp[k]=i;."<<endl;refenpei(in);cout<<"恢复数据成功!正在打印输出..."<<endl;print();}elsecout<<"找到一个安全系列：";for(i=0;i<t;i++)cout<<"P"<<temp[i]<<"--->";cout<<endl<<"已通过安全性测试!"<<endl<<endl<<endl;cout<<"开始给第"<<"p]"<<in<<"]"<<"进程分配资源..."<<endl;cout<<"分配完成!打印输出..."<<endl<<endl;print();cout<<endl;}}}五、程序运行结果及分析1、运行结果输入初值，进行安全性测试，结果安全序列，依次为P4-P0-P1-P2-P3分配资源：资源不足，无法继续实验：2、出现问题及解决方案本程序考虑了程序功能实现、格式显示合理化、输入错误异常处理等各个方面的设计，尽可能使程序设计的更加完美。
在长期的设计调试过程中遇到过许多问题，通过网上搜索、查询资料、调试试验等方法一一解决。
下面大致罗列一些主要问题：（1）、关于某些判断算法优劣问题：在程序中很多地方都会用到循环判断是否符合条件的算法，在设计这些算法时有很多方法，而有的算法可以更节省时间。
如下安全性算法中寻找寻找符合Finish[i]==0条件的进程的例子：/* 算法一：for (j=0; j<m; j++)if (Work[j]>=Need[i][j]) counter=counter+1;//记数if(counter==m){…*/ //算法二：for (j=0; j<m; j++)if (Work[j]>=Need[i][j]); //可用大于等于需求else{counter=1;break;}if(counter!=1){…显然算法二要优于算法一。
本程序中还有很多类似的地方。
这里主要考虑的是一个程序的优化设计问题。
（2）、关于某些系统函数调用时的执行顺序：在调用一些系统函数如getch() 、system("pause")等时发现其执行顺序的一些问题。
如类似：cout<<" =================================="<<endl;cout<<" \n\n\n"<<endl;system("pause");//暂停调试时发现此时：在Microsoft Visual C++ 中先执行system("pause") 再输出显示，而在调试器Bloodshed Dev-C++中则顺序执行；但当把cout<<" \n\n\n"<<endl;改为 cout<<endl<<endl<<endl; 其他不变时，则在两中调试器中均为顺序执行，即先显示后暂停。