银行家算法报告和代码

实验报告程序源代码：#include <stdio.h>#include <stdlib.h>#include <conio.h># define m 50int no1; //进程数int no2; //资源数int r;int allocation[m][m],need[m][m],available[m],max[m][m];char name1[m],name2[m]; //定义全局变量void main(){void check();void print();int i,j,p=0,q=0;char c;int request[m],allocation1[m][m],need1[m][m],available1[m];printf("**********************************************\n");printf("* 银行家算法的设计与实现 *\n");printf("**********************************************\n");printf("请输入进程总数:\n");scanf("%d",&no1);printf("请输入资源种类数:\n");scanf("%d",&no2);printf("请输入Max矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&max[i][j]); //输入已知进程最大资源需求量printf("请输入Allocation矩阵:\n");for(i=0;i<no1;i++)for(j=0;j<no2;j++)scanf("%d",&allocation[i][j]); //输入已知的进程已分配的资源数for(i=0;i<no1;i++)for(j=0;j<no2;j++)need[i][j]=max[i][j]-allocation[i][j]; //根据输入的两个数组计算出need矩阵的值printf("请输入Available矩阵\n");for(i=0;i<no2;i++)scanf("%d",&available[i]); //输入已知的可用资源数print(); //输出已知条件check(); //检测T0时刻已知条件的安全状态if(r==1) //如果安全则执行以下代码{do{q=0;p=0;printf("\n请输入请求资源的进程号(0~4)：\n");for(j=0;j<=10;j++){scanf("%d",&i);if(i>=no1){printf("输入错误，请重新输入：\n");continue;}else break;}printf("\n请输入该进程所请求的资源数request[j]:\n");for(j=0;j<no2;j++)scanf("%d",&request[j]);for(j=0;j<no2;j++)if(request[j]>need[i][j]) p=1;//判断请求是否超过该进程所需要的资源数if(p)printf("请求资源超过该进程资源需求量，请求失败！\n");else{for(j=0;j<no2;j++)if(request[j]>available[j]) q=1;//判断请求是否超过可用资源数if(q)printf("没有做够的资源分配，请求失败！\n");else //请求满足条件{for(j=0;j<no2;j++){available1[j]=available[j];allocation1[i][j]=allocation[i][j];need1[i][j]=need[i][j];//保存原已分配的资源数，仍需要的资源数和可用的资源数available[j]=available[j]-request[j];allocation[i][j]+=request[j];need[i][j]=need[i][j]-request[j];//系统尝试把资源分配给请求的进程}print();check(); //检测分配后的安全性if(r==0) //如果分配后系统不安全{for(j=0;j<no2;j++){available[j]=available1[j];allocation[i][j]=allocation1[i][j];need[i][j]=need1[i][j];//还原已分配的资源数，仍需要的资源数和可用的资源数}printf("返回分配前资源数\n");print();}}}printf("\n你还要继续分配吗？Y or N ?\n");//判断是否继续进行资源分配c=getche();}while(c=='y'||c=='Y');}}void check() //安全算法函数{int k,f,v=0,i,j;int work[m],a[m];bool finish[m];r=1;for(i=0;i<no1;i++)finish[i]=false; // 初始化进程均没得到足够资源数并完成for(i=0;i<no2;i++)work[i]=available[i];//work[i]表示可提供进程继续运行的各类资源数k=no1;do{for(i=0;i<no1;i++){if(finish[i]==false){f=1;for(j=0;j<no2;j++)if(need[i][j]>work[j])f=0;if(f==1) //找到还没有完成且需求数小于可提供进程继续运行的资源数的进程{finish[i]=true;a[v++]=i; //记录安全序列号for(j=0;j<no2;j++)work[j]+=allocation[i][j]; //释放该进程已分配的资源}}}k--; //每完成一个进程分配，未完成的进程数就减1 }while(k>0);f=1;for(i=0;i<no1;i++) //判断是否所有的进程都完成{if(finish[i]==false){f=0;break;}}if(f==0) //若有进程没完成，则为不安全状态{printf("系统处在不安全状态！");r=0;}else{printf("\n系统当前为安全状态，安全序列为：\n");for(i=0;i<no1;i++)printf("p%d ",a[i]); //输出安全序列}}void print() //输出函数{int i,j;printf("\n");printf("*************此时刻资源分配情况*********************\n");printf("进程名/号 | Max | Allocation | Need |\n"); for (i = 0; i < no1; i++){printf(" p%d/%d ",i,i);for (j = 0; j < no2; j++){printf("%d ",max[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",allocation[i][j]);}for (j = 0; j < no2; j++){printf(" %d ",need[i][j]);}printf("\n");}printf("\n");printf("各类资源可利用的资源数为:");for (j = 0; j < no2; j++){printf(" %d",available[j]);}printf("\n");}程序运行调试结果：1、程序初始化2、检测系统资源分配是否安全结果。

银行家算法流程图+C++源代码+实验报告-课程设计银行家算法流程图+C++源代码+实验报告摘要：银行家算法是避免死锁的一种重要方法。

操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。

当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。

若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。

银行家算法确实能保证系统时时刻刻都处于安全状态，但它要不断检测每个进程对各类资源的占用和申请情况，需花费较多的时间。

现在的大部分系统都没有采用这个算法，也没有任何关于死锁的检查。

关键字：银行家算法，系统安全，死琐 1，银行家算法原理银行家算法是从当前状态出发，逐个按安全序列检查各客户中谁能完成其工作，然后假定其完成工作且归还全部贷款，再进而检查下一个能完成工作的客户。

如果所有客户都能完成工作，则找到一个安全序列，银行家才是安全的。

缺点：该算法要求客户数保持固定不变，这在多道程序系统中是难以做到的；该算法保证所有客户在有限的时间内得到满足，但实时客户要求快速响应，所以要考虑这个因素；由于要寻找一个安全序列，实际上增加了系统的开销.Banker algorithm 最重要的一点是：保证操作系统的安全状态！这也是操作系统判断是否分配给一个进程资源的标准！那什么是安全状态？举个小例子，进程P 需要申请 8 个资源（假设都是一样的），已经申请了 5 个资源，还差 3 个资源。

若这个时候操作系统还剩下 2 个资源。

很显然，这个时候操作系统无论如何都不能再分配资源给进程 P 了，因为即使全部给了他也不够，还很可能会造成死锁。

若这个时候操作系统还有 3 个资源，无论 P 这一次申请几个资源，操作系统都可以满足他，因为操作系统可以保证 P 不死锁，只要他不把剩余的资源分配给别人，进程 P 就一定能顺利完成任务。

java银行家算法代码实现=================一、算法简介------银行家算法是一种用于避免系统发生死锁的算法，它通过分析系统资源分配情况，判断系统是否处于安全状态，从而避免死锁的发生。

Java银行家算法是一种基于Java语言的实现，它通过模拟系统资源分配情况，判断系统是否处于安全状态。

二、算法实现------以下是一个简单的Java银行家算法代码实现：```javapublicclassBankerAlgorithm{//资源数量和最大需求量privateint[]resource=newint[10];//例如：包括x，y，z三种资源，分别对应i-x1-x2-z...-xi-yi-zi...privateint[]maxDemand=newint[10];privateint[]available=newint[10];//当前可用资源数量privateint[]allocation=newint[10];//当前已分配资源数量privateint[]need=newint[10];//当前进程需求量privateint[]saved=newint[10];//已保存的安全序列中最后一个进程的资源需求量privateint[]process=newint[5];//进程集合，包括进程编号和进程所需资源量privateint[]processMax=newint[5];//进程最大需求量集合privateint[]systemSafe=0;//系统是否处于安全状态的标志位privateinttotalSystemSafe=0;//总共是否有足够资源可以安全运行的标志位//初始化资源分配信息publicvoidinitialize(int[][]allocationMatrix){for(inti=0;i<allocationMatrix.length;i++){process[i]=allocationMatrix[i][0];//进程编号processMax[i]=allocationMatrix[i][1];//进程最大需求量available[i]=allocationMatrix[i][2];//当前可用资源数量need[i]=allocationMatrix[i][3];//当前进程需求量maxDemand[i]=allocationMatrix[i][4];//当前进程最大需求量}systemSafe=true;//系统默认处于安全状态totalSystemSafe=true;//总共是否有足够资源可以安全运行的标志位默认设置为true}//检查系统是否处于安全状态，并返回检查结果和可能的执行序列（从开始到结束）publicboolean[]checkAndPrintSafePath(){intcurrentSystemSafe=false;//检查后的系统是否处于安全状态的标志位boolean[]safePath=newboolean[process.length];//安全序列for(inti=0;i<process.length;i++){if(need[i]<=available[i]){//如果当前进程需要的资源小于等于当前可用资源数量，则可以继续执行下去safePath[i]=true;//将当前进程标记为已执行过，并加入到安全序列中available[i]-=need[i];//将当前可用资源数量减去当前进程的已分配量，表示系统多出来的资源数量为已分配的减去需求的currentSystemSafe=true;//将当前系统的安全状态标记为true，因为已经有至少一个进程能够执行下去了}else{//如果当前进程需要的资源大于当前可用资源数量，则需要检查系统是否有足够的资源可以继续执行下去intavailableSum=0;//系统剩余的可用资源数量之和for(intj=0;j<process.length;j++){//将所有可用资源的数量累加起来availableSum+=available[j];}if(availableSum>=processMax[i]){//如果系统剩余的可用资源数量之和大于等于当前进程的最大需求量，则系统可以继续执行下去，否则需要重新分配资源并返回结果重新开始执行安全序列为null；如果为空说明不满足要求否则输出一个安全的执行序列，开始输出可执行的进程数以及所分配的资源和后续的系统安全状态标记等信息totalSystemSafe=false;//将当前系统安全状态的标志位置为false，因为此时不满足安全状态的要求，需要重新开始执行程序，且此次循环的完整性和执行性需要考虑已经完成过的安全序列重新考虑这些因素的修改可能会被重用）确保安全性序列不再更改）；再次输出完整的信息需要重新考虑这些因素以确保安全性序列不再更改）并返回结果；如果为true则说明系统已经处于安全状态并输出一个安全的执行序列；如果为false则说明。

银行家算法实验报告 Company number：【0089WT-8898YT-W8CCB-BUUT-202108】计算机操作系统实验报告一、实验名称：银行家算法二、实验目的：银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。

三、问题分析与设计：1、算法思路：先对用户提出的请求进行合法性检查，即检查请求是否大于需要的，是否大于可利用的。

若请求合法，则进行预分配，对分配后的状态调用安全性算法进行检查。

若安全，则分配；若不安全，则拒绝申请，恢复到原来的状态，拒绝申请。

2、银行家算法步骤：（1）如果Requesti＜or =Need,则转向步骤(2)；否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。

（2）如果Request＜or=Available,则转向步骤（3）；否则，表示系统中尚无足够的资源，进程必须等待。

（3）系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值：Available=Available-Request[i];Allocation=Allocation+Request;Need=Need-Request;(4)系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

3、安全性算法步骤：（1）设置两个向量①工作向量Work。

它表示系统可提供进程继续运行所需要的各类资源数目，执行安全算法开始时，Work=Allocation;②布尔向量Finish。

它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]=false，当有足够资源分配给进程时，令Finish[i]=true。

（2）从进程集合中找到一个能满足下述条件的进程：①Finish[i]=false②Need<or=Work如找到，执行步骤（3）；否则，执行步骤（4）。

（3）当进程P获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：Work=Work+Allocation;Finish[i]=true;转向步骤（2）。

计算机操作系统实验报告一、实验名称：银行家算法二、实验目的：银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。

三、问题分析与设计：1、算法思路：先对用户提出的请求进行合法性检查，即检查请求是否大于需要的，是否大于可利用的。

若请求合法，则进行预分配，对分配后的状态调用安全性算法进行检查。

若安全，则分配；若不安全，则拒绝申请，恢复到原来的状态，拒绝申请。

2、银行家算法步骤：（1）如果Requesti＜or =Need,则转向步骤(2)；否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。

（2）如果Request＜or=Available,则转向步骤（3）；否则，表示系统中尚无足够的资源，进程必须等待。

（3）系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值：Available=Available-Request[i];Allocation=Allocation+Request;Need=Need-Request;(4)系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

3、安全性算法步骤：（1）设置两个向量①工作向量Work。

它表示系统可提供进程继续运行所需要的各类资源数目，执行安全算法开始时，Work=Allocation;②布尔向量Finish。

它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]=false，当有足够资源分配给进程时，令Finish[i]=true。

（2）从进程集合中找到一个能满足下述条件的进程：①Finish[i]=false②Need<or=Work如找到，执行步骤（3）；否则，执行步骤（4）。

（3）当进程P获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：Work=Work+Allocation;Finish[i]=true;转向步骤（2）。

银行家算法实验报告实验目的：了解和掌握银行家算法，进一步熟悉进程和如何避免死锁。

实验内容：1、主要程序结构(a)resource allocation algorithm如果要求的资源量+占有的资源总的资源需求量可以carry out allocation(b) test for safety algorithm注：《--- 》中的内容为未具体写明但说明其功能的程序段bool safe(struct state new ){bool possible = true,found=false;process rest[n];//正在执行的进程号int p=n;// 正在执行的进程数量int currentavail[m];//可用资源的一个副本《---为rest和currentavail赋值---》while(possible==true&&p>0){int g=0;《---寻找可以执行完成的进程---》if(found==true){int c=0;《---假设可以执行完的进程以完成，及currentavail[*]=currentavail[*]+new.alloc[g][*];---》rest[g] = -1;--p;found =false;}else{possible=false;}}return possible;}2、实验步骤1）设计结构体#ifndef STATE_H_#define m 3#define n 5struct state{int resource[m];int available[m];int claim[n][m];int alloc[n][m];} ;#define STATE_H_#endif /* STATE_H_ */2）设计实现程序的结构的具体程序Safe算法的具体代码bool safe(struct state new ){bool possible = true,found=false;process rest[n]; //正在执行的进程号int f=0,p=n;// 正在执行的进程数量do{rest[f]=f;++f;}while(f<n);int currentavail[m]; //可用资源的一个副本int i=0;do{currentavail[i]=new.available[i];++i;}while(i<m);while(possible==true&&p>0){int g=0;/*------------------寻找可以执行完成的进程------------------------------------------*/ while(g<n){int h = 0;/*while(h<m){if((new.claim[g][h]-new.alloc[g][h])<=currentavail[h]&&rest[g]!=(-1)){if(h==m-1){found=true;}}++h;}if(found==true)break;++g;}/*-------------------------------------------------------------------------------------*/ if(found==true){int c=0;while(c<m){currentavail[c]=currentavail[c]+new.alloc[g][c];c++;}rest[g] = -1;--p;found =false;}else{possible=false;}}return possible;}实验代码：/*============================================================================ Name : pre.cAuthor :Version :Copyright : Your copyright noticeDescription : Hello World in C, Ansi-style============================================================================ */#include <stdio.h>#include <stdlib.h>#include"state.h"#define bool int#define process int#define false 0#define true 1int main(void) {bool alloc(int,int[],struct state );struct state sta1={{10,5,7},{3,3,2},{{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}},{{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}}};int request[m];int k=0;while(k>=0){puts("输入要改变资源的进程号");scanf("%d",&k);puts("输入要改变的资源");int i =0;while(i<m){scanf("%d",&request[i]);i++;}if(alloc(k,request,sta1)==true){i=0;puts("输出个进程占用的资源");while(i<n){int j=0;printf("%d ",i);while(j<m){if(i==k){sta1.alloc[k][j]=request[j]+sta1.alloc[k][j];sta1.available[j]=sta1.available[j]-request[j];}printf("%d ",sta1.alloc[i][j]);j++;}printf("\n");++i;}}puts("银行家算法");}return 0;}bool alloc(int l,int request[m],struct state nest){bool safe(struct state news);bool t = false;int i=0;while(i<m){if(nest.alloc[l][i]+request[i]>nest.claim[l][i]){puts("!!resource request error!!");return false;}else if(request[i]>nest.available[i]){puts("suspend process");return false;}else{if(i==m-1){int f=0;while(f<m){nest.alloc[l][f]=nest.alloc[l][f]+request[f];nest.available[f]=nest.available[f]-request[f];f++;}if(safe(nest)==true){t=true;}else{puts(" no safe suspend process");t=false;}}}i++;}return t;}bool safe(struct state new ){bool possible = true,found=false;process rest[n];int f=0,p=n;do{rest[f]=f;++f;}while(f<n);int currentavail[m];int i=0;do{currentavail[i]=new.available[i];++i;}while(i<m);while(possible==true&&p>0){int g=0;while(g<n){int h = 0;while(h<m&&(new.claim[g][h]-new.alloc[g][h])<=currentavail[h]&&rest[g]!=(-1)){if(h==m-1){found=true;}++h;}if(found==true)break;++g;}if(found==true){int c=0;while(c<m){currentavail[c]=currentavail[c]+new.alloc[g][c];c++;}rest[g] = -1;--p;found =false;}else{possible=false;}}return possible;}。

银行家算法java代码银行家算法是一种用于避免死锁的算法，它可以保证系统在分配资源时不会陷入死锁状态。

在操作系统中，银行家算法被广泛应用于进程调度和资源管理中。

本文将介绍银行家算法的原理和实现，并提供Java代码示例。

一、银行家算法原理银行家算法是基于资源分配图的理论基础上发展而来的。

资源分配图是描述进程和资源之间关系的一种图形表示方法。

在资源分配图中，每个进程和每个资源都表示为一个节点，进程需要的资源和已经被占用的资源之间连接一条边。

银行家算法通过模拟进程请求和释放资源的过程来判断是否会出现死锁。

当一个进程请求某些资源时，如果系统能够满足其请求，则该进程可以继续执行；否则，该进程必须等待直到有足够的资源可用。

当一个进程释放掉已经占用的某些资源时，系统会将这些资源重新分配给其他需要它们的进程。

为了避免死锁，银行家算法采取了预防措施：在分配任何一个新任务之前，先检查该任务所需求各类资料是否超过了系统现有的资料总量，如果超过了，则不予分配。

否则，再检查该任务所需求各类资料是否超过了系统现有的未分配资料总量，如果超过了，则不予分配。

二、银行家算法实现银行家算法的实现需要考虑以下几个方面：1.资源分配图的表示方法：可以使用邻接矩阵或邻接表来表示资源分配图。

2.进程请求和释放资源的模拟：可以使用数组来存储进程占用和需要的资源数量，并通过对数组的修改来模拟进程请求和释放资源的过程。

3.死锁检测：可以使用安全序列或银行家算法来判断是否会出现死锁。

下面是一个基于银行家算法实现的简单Java代码示例：public class BankerAlgorithm {// 进程数private int n;// 资源数private int m;// 各进程已占用资源数量private int[][] allocation;// 各进程尚需资源数量private int[][] need;// 系统剩余可用资源数量private int[] available;/*** 构造函数* @param n 进程数* @param m 资源数* @param allocation 各进程已占用资源数量* @param need 各进程尚需资源数量* @param available 系统剩余可用资源数量*/public BankerAlgorithm(int n, int m, int[][] allocation, int[][] need, int[] available) {this.n = n;this.m = m;this.allocation = allocation;this.need = need;this.available = available;}/*** 模拟进程请求资源* @param pid 进程ID* @param request 请求的资源数量* @return 是否满足请求*/public boolean requestResources(int pid, int[] request) { // 检查请求是否超过进程所需的资源数量for (int i = 0; i < m; i++) {if (request[i] > need[pid][i]) {return false;}}// 检查请求是否超过系统剩余的资源数量for (int i = 0; i < m; i++) {if (request[i] > available[i]) {return false;}}// 模拟进程占用资源的过程for (int i = 0; i < m; i++) {available[i] -= request[i];allocation[pid][i] += request[i];need[pid][i] -= request[i];}return true;}/*** 模拟进程释放资源* @param pid 进程ID* @param release 释放的资源数量*/public void releaseResources(int pid, int[] release) { // 模拟进程释放资源的过程for (int i = 0; i < m; i++) {available[i] += release[i];allocation[pid][i] -= release[i];need[pid][i] += release[i];}}/*** 判断系统是否安全* @return 是否安全*/public boolean isSafe() {// 初始化工作数组int[] work = new int[m];for (int i = 0; i < m; i++) {work[i] = available[i];}boolean[] finish = new boolean[n]; for (int i = 0; i < n; i++) {finish[i] = false;}// 查找可用的进程int count = 0;while (count < n) {boolean found = false;for (int i = 0; i < n; i++) {if (!finish[i]) {boolean canRun = true;for (int j = 0; j < m; j++) { if (need[i][j] > work[j]) { canRun = false;break;}}if (canRun) {finish[i] = true;found = true;count++;for (int j = 0; j < m; j++) {work[j] += allocation[i][j];}}}}if (!found) {return false;}}return true;}}三、总结银行家算法是一种重要的避免死锁的算法，它可以在系统分配资源时避免出现死锁状态。

实验四、银行家算法（一）目的和要求银行家算法是由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<<"若满足申请，系统将进入不安全状态，可能导致死锁！";}}。

#include<iostream.h>#include<string.h>#include<stdio.h>#define False 0#define True 1int 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;int N=100;//预定义void show()//显示资源矩阵{int i,j;cout<<"当前系统可用的资源[Avaliable]:"<<endl;for(i=0;i<N;i++){cout<<Name[i]<<" ";}cout<<endl;for (j=0;j<N;j++){cout<<Avaliable[j]<<" ";}//输出分配资源cout<<endl;cout<<" Max Allocation Need"<<endl;cout<<"进程名";for(j=0;j<3;j++){for(i=0;i<N;i++){cout<<Name[i]<<" ";}cout<<" ";}cout<<endl;for(i=0;i<M;i++){cout<<" "<<i<<" ";for(j=0;j<N;j++){cout<<Max[i][j]<<" ";}cout<<" ";for(j=0;j<N;j++){cout<<Allocation[i][j]<<" ";}cout<<" ";for(j=0;j<N;j++){cout<<Need[i][j]<<" ";}cout<<endl;}}int change(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,k=0,m,a,Finish[100]={0};int j;int flag=0;Work[0]=Avaliable[0];Work[1]=Avaliable[1];Work[2]=Avaliable[2];for(i=0;i<M;i++){a=0;for(j=0;j<N;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){a++;if(a==N){for(m=0;m<N;m++){Work[m]=Work[m]+Allocation[i][m];}//变分配数Finish[i]=True;Temp[k]=i;i=-1;k++;flag++;}}}}for(i=0;i<M;i++){if(Finish[i]==False){cout<<"系统不安全!"<<endl;return -1;}}cout<<"系统是安全的!"<<endl;//如果安全，输出成功cout<<"分配的序列为:";for(i=0;i<M;i++){//输出运行进程数组cout<<Temp[i];if(i<M-1){cout<<"->";}}cout<<endl;return 0;}void share()//利用银行家算法对申请资源进行判定{char ch;int i=0,j=0;ch='y';cout<<"请输入要求分配的资源进程号(0-"<<M-1<<"):";cin>>i;cout<<"请输入进程"<<i<<" 申请的资源:"<<endl;for(j=0;j<N;j++){cout<<Name[j]<<":";cin>>Request[j];}for (j=0;j<N;j++){if(Request[j]>Need[i][j]){//判断申请是否大于需求，若大于则出错cout<<"进程"<<i<<"申请的资源大于它需要的资源";cout<<" 分配不合理，不予分配！"<<endl;ch='n';break;}else {if(Request[j]>Avaliable[j]){//判断申请是否大于当前资源，若大于则出错cout<<"进程"<<i<<"申请的资源大于系统现在可利用的资源";cout<<" 分配出错，不予分配!"<<endl;ch='n';break;}}}if(ch=='y') {change(i);//根据进程需求量变换资源show();//根据进程需求量显示变换后的资源safe();//根据进程需求量进行银行家算法判断}}void add(){//添加资源int n,flag;cout<<"请输入需要添加资源种类的数量:";cin>>n;flag=N;N=N+n;for(int i=0;i<n;i++){cout<<"名称:";cin>>Name[flag];cout<<"数量:";cin>>Avaliable[flag++];}show();safe();}void delR(){//删除资源char ming;int i,flag=1;cout<<"请输入需要删除的资源名称：";do{cin>>ming;for(i=0;i<N;i++)if(ming==Name[i]){flag=0;break;}if(i==N){cout<<"该资源名称不存在，请重新输入：";} }while(flag);for(int j=i;j<N-1;j++){Name[j]=Name[j+1];Avaliable[j]=Avaliable[j+1];}N=N-1;show();safe();}void changeR(){//修改资源cout<<"系统目前可用的资源[Avaliable]:"<<endl;for(int i=0;i<N;i++){cout<<Name[i]<<":"<<Avaliable[i]<<endl;}cout<<"输入系统可用资源[Avaliable]:"<<endl;cin>>Avaliable[0]>>Avaliable[1]>>Avaliable[2];cout<<"经修改后的系统可用资源为"<<endl;for (int k=0;k<N;k++){cout<<Name[k]<<":"<<Avaliable[k]<<endl;}show();safe();}void addP(){//添加作业int flag=M;M=M+1;cout<<"请输入该作业的最大需求量[Max]"<<endl;for(int i=0;i<N;i++){cout<<Name[i]<<":";cin>>Max[flag][i];Need[flag][i]=Max[flag][i]-Allocation[flag][i];}show();safe();}int main(){int i,j,number,choice,m,n,flag;char ming;cout<<"*****************资源管理系统的设计与实现*****************"<<endl;cout<<"请首先输入系统可供资源种类的数量:";cin>>n;N=n;for(i=0;i<n;i++){cout<<"资源"<<i+1<<"的名称:";cin>>ming;Name[i]=ming;cout<<"资源的数量:";cin>>number;Avaliable[i]=number;}cout<<endl;cout<<"请输入作业的数量:";cin>>m;M=m; cout<<"请输入各进程的最大需求量("<<m<<"*"<<n<<"矩阵)[Max]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++){cin>>Max[i][j];}do{flag=0;cout<<"请输入各进程已经申请的资源量("<<m<<"*"<<n<<"矩阵)[Allocation]:"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++){cin>>Allocation[i][j];if(Allocation[i][j]>Max[i][j]){flag=1;}Need[i][j]=Max[i][j]-Allocation[i][j];}if(flag){cout<<"申请的资源大于最大需求量，请重新输入!\n";} }while(flag);show();//显示各种资源safe();//用银行家算法判定安全性while(choice){cout<<"**************银行家算法的演示***************"<<endl;cout<<" 1:增加资源2:删除资源"<<endl;cout<<" 3:修改资源4:分配资源"<<endl;cout<<" 5:增加作业0:离开"<<endl;cout<<"*******************************************"<<endl;cout<<"请选择功能号：";cin>>choice;switch(choice){case 1: add();break;case 2: delR();break;case 3: changeR();break;case 4: share();break;case 5: addP();break;case 0: choice=0;break;default: cout<<"请正确选择功能号(0-5)!"<<endl;break;}}return 1;}。

2011-2012学年第一学期计算机操作系统实验报告专业：计算机科学与技术班级：学号：姓名：提交日期：实验三银行家算法模拟【开发语言及实现平台或实验环境】C++/C#Microsoft Visual Studio 6.0/ Microsoft V isual Studio .NET 2003【实验目的】（1）进一步理解利用银行家算法避免死锁的问题；（2）在了解和掌握银行家算法的基础上，编制银行家算法通用程序，将调试结果显示在计算机屏幕上，再检测和笔算的一致性。

（3）理解和掌握安全序列、安全性算法【实验要求】（1）了解和理解死锁；（2）理解利用银行家算法避免死锁的原理；（3）会使用某种编程语言。

【实验原理】一、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列)，为每个进程分配所需的资源，直至最大需求，使得每个进程都能顺利完成。

二、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后，表示为Requesti[j]=k。

系统按下述步骤进行安全检查：（1）如果Request i≤Need i则继续以下检查，否则显示需求申请超出最大需求值的错误。

（2）如果Request i≤A vailable则继续以下检查，否则显示系统无足够资源，Pi阻塞等待。

（3）系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：A vailable［j］∶=A vailable［j］-Request i[j］;Allocation［i,j］∶=Allocation［i,j］+Request i［j］;Need［i,j］∶=Need［i,j］-Requesti［j］;（4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

《操作系统原理》实验报告银行家算法实验专业：计算机科学与技术学号：************姓名：***实验日期：2012-5-9一、实验目的通过实验用编程语言模拟银行家诉法来加强对银行家安全算法的理解和掌握。

二、实验内容熟悉避免死锁发生的方法，死锁与安全序列的关系，编程实现银行家算法，要求输出进程的安全序列。

三、算法中用到的数据结构1.可利用资源向量Available2.最大需求矩阵Max3.分配矩阵Allocation4.需求矩阵Need模拟实现银行家算法以避免死锁的出现.分两部分组成:第一部分:银行家算法(扫描)1．如果Request<=Need,则转向2;否则,出错2．如果Request<=Available,则转向3,否则等待3．系统试探分配请求的资源给进程4．系统执行安全性算法第二部分:安全性算法1.设置两个向量(1).工作向量:Work=Available(表示系统可提供给进程继续运行所需要的各类资源数目)(2).Finish:表示系统是否有足够资源分配给进程(True:有;False:没有).初始化为False2.若Finish[i]=False&&Need<=Work,则执行3;否则执行4(I为资源类别)3.进程P获得第i类资源,则顺利执行直至完成!并释放资源:Work=Work+Allocation;Finish[i]=true;转24. 若所有进程的Finish[i]=true,则表示系统安全;否则,不安全!四、算法流程图五、实现代码#include <stdio.h>#define P_NUM 5#define S_NUM 3int Max[P_NUM][S_NUM],Allocation[P_NUM][S_NUM],Need[P_NUM][S_NUM];int Available[S_NUM],Request[S_NUM];int Work[S_NUM],Finish[P_NUM],CurrentProcessId=-1,Arrange[P_NUM],CurrentId=0; FILE *fpr,*fpw;int times=0;void init(){int i=0,j=0;for(i=0;i<P_NUM;i++){for(j=0;j<S_NUM;j++){scanf("%d",&Max[i][j]);}for(j=0;j<S_NUM;j++){scanf("%d",&Allocation[i][j]);Need[i][j]=Max[i][j]-Allocation[i][j];}Finish[i]=0;}for(j=0;j<S_NUM;j++){scanf("%d",&Available[j]);}}void allocation(){int j=0,reasonable=1;if(CurrentProcessId>-1 && CurrentProcessId<P_NUM){printf("P%d Requests :( ",CurrentProcessId);for(j=0;j<S_NUM;j++){Need[CurrentProcessId][j]=Need[CurrentProcessId][j]-Request[j];Allocation[CurrentProcessId][j]=Allocation[CurrentProcessId][j]+Request[j];Available[j]=Available[j]-Request[j];printf("%d ",Request[j]);if(Need[CurrentProcessId][j]<0 || Available[j]<0)reasonable=0;}printf(")\n");if(reasonable==0){UnAllocation();printf("The Request is not reasonable! The below table is same with the top table! \n");}}}int UnAllocation(){int j=0;if(CurrentProcessId>-1 && CurrentProcessId<P_NUM){for(j=0;j<S_NUM;j++){Need[CurrentProcessId][j]=Need[CurrentProcessId][j]+Request[j];Allocation[CurrentProcessId][j]=Allocation[CurrentProcessId][j]-Request[j];Available[j]=Available[j]+Request[j];}}}void safeCheck(){int j=0,processNo=0,times=0;for(j=0;j<S_NUM;j++){Work[j]=Available[j];}processNo=meetCommand();if(processNo<0){UnAllocation();printf("this state is not safty!\n");}else{printf("Assign source in sequence :");for(j=0;j<P_NUM;j++){printf("→P%d",Arrange[j]);}printf("\n\n\n\n\n");}CurrentProcessId=-1;for(j=0;j<P_NUM;j++){Finish[j]=0;Arrange[j]=0;}}int meetCommand(){int meet=0,finish=1,i=0,j=0,maxUnFinish=0;for(i=0;i<P_NUM;i++){if(Finish[i]==0){finish=0;maxUnFinish=i;}}if(finish==1)return 0;for(i=0;i<P_NUM ;i++){if(Finish[i]==0){meet=0;for(j=0;j<S_NUM;j++){if(Need[i][j]>Work[j])meet=-1;}if(meet==0 ){Finish[i]=1;printCheckInfo(i);for(j=0;j<S_NUM;j++){Work[j]=Work[j]+Allocation[i][j];}Arrange[CurrentId]=i;CurrentId++;meetCommand();}if(i==maxUnFinish && meet==-1)return -1;}}return 0;}void printInfo(){int i=0,j=0;printf("┌───────┬────────┬─────────┬─────────┬────────┐\n");printf("││Max │Allocation │Need │Available │\n");printf("│processID ├────────┼─────────┼─────────┼────────┤\n");printf("││ A B C │ A B C │ A B C │ A B C │\n");printf("├───────┼────────┼─────────┼─────────┼────────┤\n");for(i=0;i<P_NUM;i++){printf("│P%d │",i);for(j=0;j<S_NUM;j++){printf(" %d ",Max[i][j]);}printf("│");for(j=0;j<S_NUM;j++){printf("%d ",Allocation[i][j]);}printf("│");for(j=0;j<S_NUM;j++){printf("%d ",Need[i][j]);}printf(" │");if(i==0){for(j=0;j<S_NUM;j++){printf("%d ",Available[j]);}printf(" │\n");}if(i>0)printf(" │\n");}printf("└───────┴────────┴─────────┴─────────┴────────┘\n");}int printCheckInfo(int i){int j=0,allFinsh=1;if(times==0){printf("┌───────┬────────┬─────────┬─────────┬────────┐\n");printf("││Work │Allocation │Need ││\n");printf("│processID ├────────┼─────────┼─────────┤States │\n");printf("││ A B C │ A B C │ A B C ││\n");printf("├───────┼────────┼─────────┼─────────┼────────┤\n");times++;}printf("│P%d │",i);for(j=0;j<S_NUM;j++){if(Work[j]>9)printf(" %d ",Work[j]);if(Work[j]<10)printf(" %d ",Work[j]);}printf("│");for(j=0;j<S_NUM;j++){printf("%d ",Allocation[i][j]);}printf("│");for(j=0;j<S_NUM;j++){printf("%d ",Need[i][j]);}printf(" │");for(j=0;j<P_NUM;j++){printf("%d ",Finish[j]);allFinsh*=Finish[j];}printf(" │\n");if(allFinsh==0)printf("├───────┼────────┼─────────┼─────────┼────────┤\n");if(allFinsh> 0)printf("└───────┴────────┴─────────┴─────────┴────────┘\n");}main(){int j=0;char comeOn;fpr = fopen("banker.txt","r");fpw = fopen("outcoming.txt","w");printf("程序运行结果如下：\n");init();printInfo();allocation();safeCheck();scanf("\n%c",&comeOn);while(comeOn=='y'|| comeOn=='Y'){printInfo();scanf("%d",&CurrentProcessId);for(j=0;j<S_NUM;j++){scanf("%d",&Request[j]);}allocation();times=0;CurrentId=0;safeCheck();scanf("\n%c",&comeOn);}}六、总结通过了这次实验更透彻的理解了银行家算法如何来避免思索的产生，以及对银行家算法的具体实现步骤更加清晰的理解。

银行家算法实验报告 The pony was revised in January 2021计算机操作系统实验报告何美西一、实验名称：银行家算法二、实验目的：银行家算法是避免死锁的一种重要方法，通过编写一个简单的银行家算法程序，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。

三、问题分析与设计：1、算法思路：先对用户提出的请求进行合法性检查，即检查请求是否大于需要的，是否大于可利用的。

若请求合法，则进行预分配，对分配后的状态调用安全性算法进行检查。

若安全，则分配；若不安全，则拒绝申请，恢复到原来的状态，拒绝申请。

2、银行家算法步骤：（1）如果Requesti＜or =Need,则转向步骤(2)；否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。

（2）如果Request＜or=Available,则转向步骤（3）；否则，表示系统中尚无足够的资源，进程必须等待。

（3）系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数值：Available=Available-Request[i];Allocation=Allocation+Request;Need=Need-Request;(4)系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

3、安全性算法步骤：（1）设置两个向量①工作向量Work。

它表示系统可提供进程继续运行所需要的各类资源数目，执行安全算法开始时，Work=Allocation;②布尔向量Finish。

它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]=false，当有足够资源分配给进程时，令Finish[i]=true。

（2）从进程集合中找到一个能满足下述条件的进程：①Finish[i]=false②Need<or=Work如找到，执行步骤（3）；否则，执行步骤（4）。

（3）当进程P获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：Work=Work+Allocation;Finish[i]=true;转向步骤（2）。

计算机操作系统教程（第三版）银行家算法实验报告一、实验目的银行家算法是避免死锁的一种重要方法。

通过编写一个模拟动态资源分配的银行家算法程序，进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法二、实验要求根据银行家算法的基本思想，编写和调试一个实现动态资源分配的模拟程序，并能够有效地防止和避免死锁的发生。

（1）设计思想说明设计银行家算法是为了避免死锁三、实验方法内容1.算法设计思路银行家算法又称“资源分配拒绝”法，其基本思想是，系统中的所有进程放入进程集合，在安全状态下系统受到进程的请求后试探性的把资源分配给他，现在系统将剩下的资源和进程集合中其他进程还需要的资源数做比较，找出剩余资源能满足最大需求量的进程，从而保证进程运行完成后还回全部资源。

这时系统将该进程从进程集合中将其清除。

此时系统中的资源就更多了。

反复执行上面的步骤，最后检查进程的集合为空时就表明本次申请可行，系统处于安全状态，可以实施本次分配，否则，只要进程集合非空，系统便处于不安全状态，本次不能分配给他。

请进程等待2.算法流程图3.算法中用到的数据结构数据结构的说明1.可利用资源向量AVAILABLE。

这是一个含有M个元素的数组，其中的每一个元素代表一类可利用的资源数目，其3初始值是系统中所配置的该类全部可哦那个资源的数目，其数值随该类资源的分配和回收而动态的改变。

2.最大需求矩阵MAX。

这是一个M*N的矩阵，它定义了系统中N个进程中的每一个进程对M类资源的最大需求。

3.分配矩阵ALLOCATION。

这也是一个M*N的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。

4.需求矩阵NEED。

这也是一个M*N的矩阵，用以表示每一个进程尚需的各类资源数。

5.NEED[R,W]=MAX[R,W]-ALLOCATION[R,W]4.主要的常量变量#define W 10 //最大进程数W=10#define R 20 //最大资源总数R=20 int AVAILABLE[R]; //可利用资源向量int MAX[W][R]; //最大需求矩阵int ALLOCATION[W][R]; //分配矩阵int NEED[W][R]; //需求矩阵int Request[R]; //进程请求向量void changdata(int k);//进程请求资源数据改变int chksec(int s); //系统安全性的检测5.主要模块void inputdata()void showdata()void changdata(int k)void restoredata(int k) int chksec(int s)int chkmax(int s)四、实验代码#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.结果分析银行家算法就是当接收到一个系统资源的分配后找到一个安全序列，使得进程间不会发生死锁，若发生死锁则让进程等待。

目录目录 (1)第一章绪论 (2)1.1 综述 (2)1.2 设计地点 (2)1.3 设计目的 (2)1.4 设计意义 (2)1.5 设计内容 (3)1.6 实验环境 (3)第二章程序设计与实现 (3)2.1 详细设计 (3)2.1.1 初始化 (3)2.1.2 银行家算法 (3)2.1.3 安全性算法 (4)2.1.4 各算法流程图 (4)2.1.5 关键代码分析 (6)第三章调试与运行 (7)3.1 初始化程序 (7)3.2 选择操作 (7)3.3 显示资源分配情况 (8)3.4 安全分配 (8)3.5 请求拒绝 (9)3.5.1 资源请求超过进程需要 (9)3.5.2 资源请求后系统不安全 (9)3.5 退出系统 (9)第四章结论 (10)参考文献 (11)附录：源程序清单 (12)第一章绪论1.1 综述如果一组进程中的每一个进程都在等待，仅由该组进程中的其他进程才能引发的事件，因此就引起了死锁，目前处理死锁的方法有：预防死锁、避免死锁、检测死锁和接触死锁。

银行家算法是最具有代表性的避免死锁的算法。

本次课程设计在本着加强课本知识运用能力的前提下，我选取了银行家算法这个题目。

该题目主要是针对操作系统中容易出现死锁问题设计了一个避免死锁的算法。

为实现银行家算法，每一个新进程在进入系统时，它必须申明在运行进程中，可能需要的每种资源类型的最大单元数目，其数目不应该超过系统所拥有的资源总量。

当进程请求一组资源时，系统必须首先确定是否有足够的资源分配给该进程。

若有，再进一步计算，在将这些资源分配给进程后，是否会使系统处于不安全状态。

如果不会，才将资源分配给它，否则让进程等待。

题目设计在Visual C++ 6.0应用软件或者Linux终端下运行通过。

程序设计过程还得到了老师和同学的指导和帮助，在此表示深深的感谢！1.2 设计地点图书馆五楼计算机系软二机房1.3 设计目的在Linux或者Windows XP下用某种高级语言，来模拟银行家算法和安全算法类避免死锁的发生。

银行家算法的代码（c语言）#include#include#include# define m 50# define true 1# define false 0int 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请输入请求资源的进程号：\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{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(); //检测分配后的安全性i</no2;j++)</no2;j++)</no2;j++)</no2;i++)</no2;j++)</no1;i++)</no2;j++)</no1;i++)</no2;j++)</no1;i++)f(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];int 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{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");}</no1;i++)</no2;j++)</no2;j++)</no1;i++)</no2;i++)</no1;i++)</no2;j++)。

#include <iostream.h>#include <string.h>#define M 3 //资源的种类数#define N 5 //进程的个数int i ,j;void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]); //统一的输出格式bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);bool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]);bool tr[N]={false,false,false,false,false};int iMax[N][M]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};int main(){//当前可用每类资源的资源数int iAvailable[M]={3,3,2};//系统中N个进程中的每一个进程对M类资源的最大需求//iNeed[N][M]每一个进程尚需的各类资源数//iAllocation[N][M]为系统中每一类资源当前已分配给每一进程的资源数int iNeed[N][M],iAllocation[N][M]={{0,1,1},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//进程名char cName[N]={'a','b','c','d','e'};bool bExitFlag=true; //退出标记char ch; //接收选择是否继续提出申请时传进来的值bool bSafe; //存放安全与否的标志//计算iNeed[N][M]的值for(i=0;i<N;i++)for(j=0;j<M;j++)iNeed[i][j]=iMax[i][j]-iAllocation[i][j];//输出初始值output(iMax,iAllocation,iNeed,iAvailable,cName);//判断当前状态是否安全bSafe=safety(iAllocation,iNeed,iAvailable,cName);//是否继续提出申请while(bExitFlag){cout<<"\n"<<"继续提出申请？\ny为是；n为否。

课程设计（论文）题 目： 银行家算法 院 （系）： 信息与控制工程系 专业班级： 姓 名： 学 号： 指导教师：2016 年 1 月 15 日西安建筑科技大学华清学院课程设计（论文）任务书专业班级： 学生姓名：指导教师（签名）：一、课程设计（论文）题目银行家算法：设计一个 n 个并发进程共享 m 个系统资源的程序以实现银行家算法。

二、本次课程设计（论文）应达到的目的操作系统课程实践性比较强。

课程设计是加强学生实践能力的一个强有力手段。

课程设计要求学 生在完成程序设计的同时能够写出比较规范的设计报告。

严格实施课程设计这一环节，对于学生基本 程序设计素养的培养和软件工作者工作作风的训练，将起到显著的促进作用。

本题目要达到目的：了解多道程序系统中，多个进程并发执行的资源分配。

掌握银行家算法，了 解资源在进程并发执行中的资源分配情况。

掌握预防死锁的方法，系统安全状态的基本概念。

三、本次课程设计（论文）任务的主要内容和要求（包括原始数据、技术参 数、设计要求等）要求： 1）能显示当前系统资源的占用和剩余情况。

2）为进程分配资源，如果进程要求的资源大于系统剩余的资源，不与分配并且提示分配不成功； 3）撤销作业，释放资源。

编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用适当的算法， 有效地防止和避免死锁的发生。

银行家算法分配资源的原则是：系统掌握每个进程对资源的最大需求量，当进程要求申请资源时， 系统就测试该进程尚需资源的最大量，如果系统中现存的资源数大于或等于该进程尚需求资源最大量 时，就满足进程的当前申请。

这样就可以保证至少有一个进程可能得到全部资源而执行到结束，然后 归还它所占有的全部资源供其它进程使用。

四、应收集的资料及主要参考文献：操作系统经典算法的编程实现资料非常丰富，可以在图书馆找书籍或在因特网上找资料，都很容 易找到，但是大部分代码是不全的，不能直接运行，希望大家只是把它当参考，编码还是自己做。