银行家算法及安全算法

合集下载

银行家算法总结

银行家算法总结

银行家算法总结银行家算法是一种经典的避免死锁的算法,在操作系统中得到了广泛的应用。

本文将对银行家算法进行总结,介绍其原理和应用。

## 1. 银行家算法简介银行家算法是一种资源分配和安全性检查的算法,用于避免在多个进程竞争有限资源时产生死锁。

它通过预先分配资源,检查每个进程请求资源后是否会导致系统进入不安全状态,从而避免死锁的发生。

## 2. 银行家算法原理银行家算法基于以下前提条件和原理:- 每个进程对资源的最大需求量是固定的,并在程序开始时规定。

- 系统中的资源被分为多类,每类资源的数目也是固定的。

- 每个进程在请求资源时需要指定所需资源的数量。

- 当进程请求资源时,系统会先检查此次请求是否安全,如果安全则分配资源,否则将此次请求置于等待状态。

银行家算法的原理可以归纳为以下几个步骤:1. 初始化阶段:系统初始化可分配资源和进程的最大需求量,并记录当前已分配资源和已请求资源的情况。

2. 请求资源阶段:当进程请求资源时,系统首先判断此次请求是否会导致系统进入不安全状态。

3. 安全检查阶段:系统通过安全性检查算法,判断当前系统状态下是否有足够的资源分配给进程,避免产生死锁。

4. 分配资源阶段:如果系统通过安全检查,则分配资源给进程,并将进程从等待状态转换为运行状态。

5. 进程释放资源:当进程完成任务后,释放已分配的资源。

6. 终止进程阶段:在释放资源后,检查是否有其他进程的请求可以被满足,如果满足则继续分配资源。

## 3. 银行家算法应用场景银行家算法主要应用于多进程共享有限资源的场景,如操作系统、数据库管理系统等。

以下是一些常见的应用场景:1. 操作系统资源管理:在多任务操作系统中,为了确保资源的高效利用,避免死锁的发生,可以使用银行家算法进行资源分配和调度。

2. 分布式系统:在分布式系统中,各个节点之间可能存在资源争用的情况。

使用银行家算法可以保证资源的分配和调度是安全的,避免死锁和资源竞争。

3. 并发编程:在并发编程中,多个线程可能会竞争同一资源。

操作系统实验二:银行家算法

操作系统实验二:银行家算法

操作系统实验⼆:银⾏家算法实验⼆银⾏家算法⼀、实验⽬的1、了解什么是操作系统安全状态和不安全状态;2、了解如何避免系统死锁;3、理解银⾏家算法是⼀种最有代表性的避免死锁的算法,掌握其实现原理及实现过程。

⼆、实验内容根据银⾏家算法的基本思想,编写和调试⼀个实现动态资源分配的模拟程序,并能够有效避免死锁的发⽣。

三、实验原理进程申请资源时,系统通过⼀定的算法判断本次申请是否不可能产⽣死锁(处于安全状态)。

若可能产⽣死锁(处于不安全状态),则暂不进⾏本次资源分配,以避免死锁。

算法有著名的银⾏家算法。

1、什么是系统的安全状态和不安全状态?所谓安全状态,是指如果系统中存在某种进程序列<P1,P2,…,Pn>,系统按该序列为每个进程分配其所需要的资源,直⾄最⼤需求,则最终能使每个进程都可顺利完成,称该进程序列<P1,P2,…,Pn,>为安全序列。

如果不存在这样的安全序列,则称系统处于不安全状态。

2、银⾏家算法把操作系统看作是银⾏家,操作系统管理的资源相当于银⾏家管理的资⾦,进程向操作系统请求分配资源相当于⽤户向银⾏家贷款。

为保证资⾦的安全,银⾏家规定:(1) 当⼀个顾客对资⾦的最⼤需求量不超过银⾏家现有的资⾦时就可接纳该顾客;(2) 顾客可以分期贷款,但贷款的总数不能超过最⼤需求量;(3) 当银⾏家现有的资⾦不能满⾜顾客尚需的贷款数额时,对顾客的贷款可推迟⽀付,但总能使顾客在有限的时间⾥得到贷款;(4) 当顾客得到所需的全部资⾦后,⼀定能在有限的时间⾥归还所有的资⾦。

操作系统按照银⾏家制定的规则设计的银⾏家算法为:(1)进程⾸次申请资源的分配:如果系统现存资源可以满⾜该进程的最⼤需求量,则按当前的申请量分配资源,否则推迟分配。

(2)进程在执⾏中继续申请资源的分配:若该进程已占⽤的资源与本次申请的资源之和不超过对资源的最⼤需求量,且现存资源能满⾜该进程尚需的最⼤资源量,则按当前申请量分配资源,否则推迟分配。

(3)⾄少⼀个进程能完成:在任何时刻保证⾄少有⼀个进程能得到所需的全部资源⽽执⾏到结束。

简述银行家算法

简述银行家算法

简述银行家算法银行家算法,也称为银行家安全算法,是一种用于避免系统资源的死锁现象的算法。

在操作系统中,当多个进程需要同时访问同一组资源并且它们的访问不可分割时,就会产生死锁现象。

在这种情况下,所有的进程都会被阻塞,无法进行任何工作。

银行家算法通过对系统资源的分配和管理,可以避免死锁现象的发生。

它主要包括以下几个步骤:1. 初始化系统:在系统启动时,需要确定每种类型的资源的数量和可用数量,并记录每个进程需要的最大资源数和已经分配的资源数。

2. 进行资源请求:当一个进程需要资源时,会向系统发送一个资源请求。

该请求指定了进程需要的资源类型和数量。

如果系统中有足够的资源可以分配给该进程,那么分配成功并将资源分配给该进程。

3. 检查资源分配是否安全:在分配资源之前,需要检查分配后系统是否处于安全状态。

安全状态是指在分配后,所有进程都能够完成它们的工作并释放所有资源。

如果系统处于安全状态,则分配资源并通知进程可以执行它们的任务。

4. 回收资源:当进程完成任务后,会释放它所占用的所有资源并通知系统。

系统会将这些资源重新分配给其他进程。

在银行家算法中,对于每个进程,都会维护一个资源请求向量和一个安全向量。

资源请求向量包含了进程当前所需要的资源数量,安全向量包含了系统中未分配的资源数量。

当系统收到一个资源请求时,会将该请求向量加入到系统资源向量中,并检查是否存在一个安全序列,该安全序列满足所有进程都可以完成它们的任务并释放它们所占用的所有资源。

如果存在这样的安全序列,则分配资源并通知进程可以执行它们的任务;如果不存在,则拒绝资源请求并等待其他进程的资源释放。

通过使用银行家算法,可以避免系统中的死锁现象,保证所有进程都可以完成它们的任务。

这种算法被广泛应用于操作系统和其他复杂的软件系统中,是保障系统安全性的重要工具。

银行家算法iebo.pptx

银行家算法iebo.pptx

12
Allocation
CNhaepetedr 3 处理机调度与死锁
P0
010
743
P1
200
122
P2
302
600
P3
211
011
P4
002
431
Work P1 3 3 2 P3 5 3 2 P0 7 4 3
Need 122 011 743
Allocation Work+Allocation Finish
100 012 300 010 210
Available r1 r2 r3
120
26
练习
试问: 1) 该状态是否安全? 2) 如果进程P2提出请求Request(0,1,0),系统
能否将资源分配给它? 3) 如果系统立即满足P2的上述请求,则系统是否
立即进入死锁状态?
27
Need 122 011 743 600
Allocation Work+Allocation Finish
2 0 0 5 3 2 true
2 1 1 7 4 3 true
010 302
7 5 3 true 10 5 5 true
14
Allocation
CNhaepetedr 3 处理机调度与死锁
P0
19
银行家算法实例
④ 执行安全性算法: a. Work :=Available=(2, 3, 0); Finish[ i ]:=false;
b. 在进程集合中找到 Need1=(0, 2, 0) ≤Work;
c. 则设 P1可顺利执行完成,从而有: Work :=Work+Allocation1 =(2, 3, 0)+(3, 0, 2)=(5, 3, 2) Finish[ 1 ]:=true

银行家算法总结

银行家算法总结

银行家算法总结一、银行家算法银行家算法(Banker’s Algorithm),又称银行家管理算法,是一种专门用于系统资源管理的算法,用于解决操作系统中多个用户对多类资源的竞争请求,从而保证合理地分配公共资源,解决资源分配问题,其目的是为了保证单个进程的安全运行,同时保证系统的安全运行。

二、银行家算法的定义银行家算法是一种用于解决多个用户对多类资源的竞争请求的算法,也称作资源分配算法或资源管理算法,它可以确定是否有足够的资源可供一个或多个进程安全运行,如果有足够的资源可供运行,则可以分配该资源,否则系统将进入不满足安全状态。

三、银行家算法的特点(1)安全性:银行家算法可以确定是否有足够的资源可以满足所有进程的最大要求,使系统处于安全态;(2)在安全态下,银行家算法能够有效地检查一个进程是否可以获得资源,并且可以确定该状态下的最优解;(3)银行家算法可以有效检查一个系统是否处于安全态,它可以检查任意多个资源种类的一组资源分配是否安全;(4)银行家算法可以防止死锁的发生,可以有效地确保非抢占式多处理机系统的安全运行;(5)银行家算法设计简单,容易实现,并十分快速;(6)银行家算法不是最优的,它只是一种有效的搜索算法,其实现效率较低;四、银行家算法的使用1、资源分配问题银行家算法可以用于操作系统中的多个用户对多类资源的竞争请求,以此保证资源的合理分配,从而解决资源分配问题。

它可以有效地检查一个进程是否可以获得资源,同时可以确定该状态下的最优解。

2、进程安全性银行家算法可以用于检查一个系统是否处于安全态,并检查任意多个资源种类的一组资源分配是否安全,可以保证系统的安全运行,从而保证单个进程的安全性。

3、防止死锁银行家算法可以防止死锁的发生,这是由于它可以确定是否有足够的资源可以满足所有进程的最大要求,使系统处于安全态,从而阻止死锁发生。

总结银行家算法的算法思想

总结银行家算法的算法思想

总结银行家算法的算法思想银行家算法(Banker's algorithm)是一种用于避免死锁的资源分配算法。

它是由荷兰计算机科学家埃德赫尔特·迪科斯彻在1965年提出的,其核心思想是通过判断系统状态是否安全来避免资源分配导致的死锁。

银行家算法的基本思想是在进行资源分配之前,通过模拟执行来判断系统是否会进入不安全状态。

具体来说,该算法需要维护一些数据结构,包括进程的最大需求矩阵、已分配资源矩阵、可用资源矩阵和需求资源矩阵。

通过这些矩阵的计算和比较,可以判断出系统是否能够分配资源,并避免死锁情况的出现。

银行家算法的算法过程如下:1. 初始化:将进程的最大需求矩阵、已分配资源矩阵、可用资源矩阵和需求资源矩阵进行初始化。

2. 安全性检查:通过循环遍历每个进程,判断当前系统状态是否安全。

具体的判断标准是,判断每个进程的需求资源矩阵是否小于等于可用资源矩阵,若满足条件,则代表该进程可以执行,否则代表该进程无法执行。

3. 执行分配:如果当前系统状态安全,则将资源分配给进程执行,并更新已分配资源矩阵和可用资源矩阵。

4. 释放资源:当进程执行完毕后,释放已占有资源,并更新已分配资源矩阵和可用资源矩阵。

银行家算法的核心思想是通过安全性检查来避免死锁的发生。

在进行资源分配之前,系统会先进行模拟执行,判断系统状态是否安全。

如果系统是安全的,则资源会分配给进程执行;否则,资源不会分配,并保持当前状态。

这样可以防止资源的过度分配和不合理分配,进而减少死锁的发生。

银行家算法的优点是避免了资源的浪费和不合理分配,保证了系统的高效运行。

同时,该算法也能够避免死锁的产生,提高了系统的稳定性和可靠性。

然而,银行家算法也存在一些局限性。

首先,该算法要求进程提前声明对资源的最大需求,而实际情况下,有些进程可能无法准确地预先声明自己的资源需求。

其次,该算法需要维护多个矩阵,增加了算法的复杂性和计算量。

最后,银行家算法只是一种静态的资源分配算法,无法适应动态变化的系统需求。

银行家算法计算安全序列

银行家算法计算安全序列
银行家算法是一种用于判断系统资源分配是否安全的算法,用于避免死锁的发生。

安全序列是指系统能够按照一定的顺序满足所有进程的资源需求,同时避免死锁的发生。

下面是银行家算法计算安全序列的基本步骤:
1. 初始化:设置一个长度为n的数组work,代表可用资源的
数量,初始值为系统中每个资源的可用数量。

设置一个长度为
n的数组finish,用于记录每个进程是否已经得到了全部所需
资源,初始值均为false。

2. 循环检测:循环遍历进程,检查当前进程是否满足以下条件: - finish[i]为false(即当前进程未得到所需资源)
- 当前进程所需的资源量小于等于work(即系统有足够的资
源供当前进程使用)
如果满足以上条件,则将当前进程加入安全序列,并更新work的值,即work = work + allocation[i]。

将finish[i]设为true,表示当前进程已经得到了所需资源。

继续循环直到所有进程都满足以上条件或者没有进程满足以
上条件为止。

3. 检查安全性:检查是否存在一个安全序列,即所有进程都已经得到了所需的资源。

如果存在安全序列,则系统是安全的;否则,系统是不安全的。

通过以上步骤,可以计算出一个安全序列,用于判断系统资源分配是否安全。

银行家算法

银行家算法一、基本思想:银行家算法是最具有代表性的避免死锁的算法,在本实验中是用C语言实现的。

具体做法是:银行家算法中的数据结构:1、定义一个含有m 个元素的Available数组,每一个元素表示一类可利用的资源数,其值随该类资源的分配和回收而动态的改变。

2、定义一个最大需求矩阵Max,它是一个二维数组,表示每个进程对某类资源的最大需求。

3、定义一个分配矩阵Allocation,它也是一个二维数组,表示系统中每一个进程已经得到的每一类资源的数目。

4、定义一个需求矩阵Need,它也是一个二维数组,表示每个进程尚需的各类资源数。

当某个进程发出资源请求,系统按下述步骤进行检查:1、如果请求向量小于需求矩阵,便执行下一步;否则认为出错,因为它所需要的资源已超过它所宣布的最大值。

2、如果请求向量小于可利用的资源数,便执行下一步;否则,资源不足,该进程需要等待。

3、系统试探着把资源分配给该进程,并修改下列数据结构中的数值:剩余资源数等于可用资源数减去需求向量;已分配的资源数等于为请求资源前分配给该进程的资源加上需求向量;需求矩阵等于未分配资源前的需求矩阵减去请求向量;4、系统执行安全性算法,检查此次分配后系统是否处于安全状态。

若安全,才将资源分配给该进程;否则,本次试探分配作废。

安全性算法:(1)设置两个工作向量Work=Available;Finish[M]=FALSE(2)从进程集合中找到一个满足下述条件的进程,Finish[i]=FALSENeed<=Work如找到,执行(3);否则,执行(4)(3)设进程获得资源,可顺利执行,直至完成,从而释放资源。

Work= Work + AllocationFinish =True; 转向执行步骤(@)(4)如所有的进程Finish[M]=true,则表示安全;否则系统不安全。

二、源程序代码:#define M 10#include<stdio.h>int resource[M];max[M][M],allocation[M][M],need[M][M],available[M];int i,j,n,m,r;void testout() //算法安全性的检测{ int k,flag,v=0;int work[M],a[M];char finish[M];r=1;for(i=0;i<n; i++)finish[i]='F'; //初始化各进程均没得到足够资源for(j=0;j<m; j++)work[j]=available[j]; //用work[j]表示可提供进程继续运行的各类资源数k=n;while(k>0){for (i=0;i<n; i++){if (finish[i]=='F'){ flag=1;for (j=0;j<m; j++)if (need[i][j]>work[j])flag=0;if (flag==1) //找到还没完成的且需求数小于可提供进程继续运行的{ finish[i]='T'; //资源数的进程a[v++]=i; //记录安全序列for (j=0;j<m; j++)work[j]=work[j]+allocation[i][j]; //释放该进程已分配的资源}}}k--;}flag=1;for (i=0;i<n; i++) //判断是否所有的进程都完成if (finish[i]=='F')flag=0;if (flag==0) //若有进程没完成,则为不安全状态{printf("系统不安全. \n");r=0;}else //否则为安全状态{printf("系统是安全的.\n");printf(" 输出安全序列:\n");for (i=0;i<n;i++)printf ("%d ",a[i]); //输出安全序列printf("\n");printf("为各进程分配分配各类资源的方法:\n");for (i=0;i<n; i++){printf("%2d",i);printf(" ");for(j=0;j<m; j++)printf("%2d",allocation[i][j]);printf(" ");for(j=0;j<m; j++)printf("%2d",need[i][j]);printf("\n");}}}void print() //输出可用资源数目{printf("可用资源是: \n");for(j=0;j<m; j++)printf("%2d ",available[j]);printf("\n");}void main(){int p,q;int resource[M],request[M],allocation1[M][M],need1[M][M],available1[M];printf("输入进程总数:\n");scanf("%d", &n);printf("输入资源种类总数:\n");scanf("%d", &m);printf("输入各类资源总数:\n");for(j=0;j<m;j++)scanf("%2d",&resource[j]);printf("各类资源的总数:\n");for(j=0;j<m;j++)printf("资源%d: %d\n",j,resource[j]);printf("输入最大矩阵:\n");for(i=0;i<n; i++)for(j=0;j<m; j++)scanf("%2d",&max[i][j]);printf("输入已分配资源数:\n");for(i=0;i<n; i++)for(j=0;j<m; j++)scanf("%d", &allocation[i][j]);printf("输出还需要的资源数:\n");for (i=0;i<n; i++){for(j=0;j<m; j++){need[i][j]=max[i][j]-allocation[i][j];printf("%2d",need[i][j]);}printf("\n");}printf("\n输入可用资源数:\n");for (i=0;i<m; i++)scanf("%d", &available[i]);testout(); //检测已知的状态是否安全if (r==1) //如果状态安全则执行以下代码{while (1){ p=0;q=0;printf("\n输入请求资源的进程号: \n");scanf("%d", &i);printf("输入该进程所需的资源数:\n");for(j=0;j<m; j++)scanf("%d",&request[j]);for(j=0;j<m; j++)if(request[j]>need[i][j])p=1; //判断是否超过最大资源数if(p)printf("请求超过最大资源数!\n");else{for(j=0;j<m; j++)if(request[j]>available[j])q=1; //判断是否超过可用资源数if(q)printf("没有足够的可用资源!\n");else{for(j=0;j<m; 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]=allocation[i][j]+request[j];need[i][j]=need[i][j]-request[j];}print(); //输出可用资源数testout(); //进行安全检测if(r==0) //分配后状态不安全{for (j=0;j<m; j++){ available[j]=available1[j]; //还原分配前的已分配的资源数,仍需要的资源数和可用的资源数allocation[i][j]=allocation1[i][j];need[i][j]=need1[i][j];}printf(" 不安全,请返回!\n");print();}}}}}}三、实验结果截图:。

银行家算法的资源利用率分析

银行家算法的资源利用率分析银行家算法(Banker's Algorithm)是一种资源分配算法,用于确保在多个进程同时请求资源时,系统能够避免死锁的发生。

它通过预先判断进程所需的资源是否能够被满足,来决定是否能够分配资源给该进程。

本文将深入探讨银行家算法的资源利用率分析,并分享对该算法的见解。

1. 算法背景及原理解析银行家算法最早由E. W. Dijkstra在1965年提出,它针对系统资源的请求和释放情况进行管理,以避免出现死锁。

在实际应用中,操作系统通过使用银行家算法来分配进程所需的资源,从而保证系统的稳定性和安全性。

银行家算法的基本原理是基于资源的安全性来进行资源的分配。

它通过判断系统是否处于安全状态,即是否存在一种资源分配的序列,使得所有进程都能够完成并释放资源,而不会发生死锁。

2. 资源利用率的分析银行家算法的目标之一是实现资源的高效利用。

通过对资源的分配和释放进行控制,可以使系统的资源利用率达到最佳状态。

资源利用率的分析可以从以下几个方面来进行:2.1 资源分配策略银行家算法采用的资源分配策略是基于安全性和资源的可用性。

系统在分配资源时需要检查分配给某个进程后是否仍然能够保持安全状态,如果安全则允许分配,否则需要等待。

这样可以保证资源的合理利用,避免出现死锁和资源浪费的情况。

2.2 资源释放机制当进程完成任务后,银行家算法需要及时释放已占用的资源,以便其他进程能够继续使用。

资源释放的及时性可以提高资源的利用率,并且避免资源被长时间占用而导致其他进程无法执行的情况。

2.3 资源回收与再利用银行家算法还可以通过回收已释放的资源,并将其重新分配给其他进程,以提高资源的再利用率。

这样可以减少资源的浪费,使得系统资源得到更加充分地利用。

3. 观点与理解银行家算法在资源管理和分配方面具有重要的意义。

它通过合理分配和利用系统资源,确保系统的稳定性和安全性,避免了死锁的发生。

这对于大规模的多用户系统尤为重要,能够有效提高系统性能和资源利用率。

实验三 银行家算法

实验三银行家算法一、实验目的死锁会引起计算机工作僵死,因此操作系统中必须防止。

本实验的目的在于使用高级语言编写和调试一个系统动态分配资源的简单模拟程序,了解死锁产生的条件和原因,并采用银行家算法有效地防止死锁的发生,以加深对课堂上所讲授的知识的理解。

二、实验要求设计有n个进程共享m个系统资源的系统,进程可动态的申请和释放资源,系统按各进程的申请动态的分配资源。

系统能显示各个进程申请和释放资源,以及系统动态分配资源的过程,便于用户观察和分析;三、数据结构1.可利用资源向量Available ,它是一个含有m个元素的数组,其中的每一个元素代表一类可利用的资源的数目,其初始值是系统中所配置的该类全部可用资源数目。

其数值随该类资源的分配和回收而动态地改变。

如果Available(j)=k,标是系统中现有Rj类资源k个。

2.最大需求矩阵Max,这是一个n×m的矩阵,它定义了系统中n个进程中的每一个进程对m类资源的最大需求。

如果Max(i,j)=k,表示进程i需要Rj类资源的最大数目为k。

3.分配矩阵Allocation,这是一个n×m的矩阵,它定义了系统中的每类资源当前一分配到每一个进程的资源数。

如果Allocation(i,j)=k,表示进程i当前已经分到Rj类资源的数目为k。

Allocation i表示进程i的分配向量,有矩阵Allocation的第i行构成。

4.需求矩阵Need,这是一个n×m的矩阵,用以表示每个进程还需要的各类资源的数目。

如果Need(i,j)=k,表示进程i还需要Rj类资源k个,才能完成其任务。

Need i表示进程i的需求向量,由矩阵Need 的第i行构成。

上述三个矩阵间存在关系:Need(i,j)=Max(i,j)-Allocation(i,j);四、银行家算法Request i是进程Pi 的请求向量。

Request i(j)=k表示进程Pi请求分配Rj类资源k个。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验名称:银行家算法实验时间:2015.04.20实验目的:1:利用银行家算法避免死锁2:掌握银行家算法的基本原理3:掌握安全算法的基本原理实验仪器:PC vc6.0实验原理:1:银行家算法的基本原理2:安全算法的基本原理实验内容:请使用银行家算法来避免死锁的产生程序代码:(供参考)#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;//作业的最大数为100int N=100;//资源的最大数为100void showdata()//显示资源矩阵{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 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,k=0,m,apply,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++){apply=0;for(j=0;j<N;j++){if (Finish[i]==False&&Need[i][j]<=Work[j]){apply++;if(apply==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') {changdata(i);//根据进程需求量变换资源showdata();//根据进程需求量显示变换后的资源safe();//根据进程需求量进行银行家算法判断}}void addresources(){//添加资源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++];}showdata();safe();}void delresources(){//删除资源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;showdata();safe();}void changeresources(){//修改资源函数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; showdata();safe();}void addprocess(){//添加作业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]; }showdata();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);showdata();//显示各种资源safe();//用银行家算法判定系统是否安全while(choice){cout<<"**************银行家算法演示***************"<<endl;cout<<" 1:增加资源"<<endl;cout<<" 2:删除资源"<<endl;cout<<" 3:修改资源"<<endl;cout<<" 4:分配资源"<<endl;cout<<" 5:增加作业"<<endl;cout<<" 0:离开"<<endl;cout<<"*******************************************"<<endl;cout<<"请选择功能号:";cin>>choice;switch(choice){case 1: addresources();break;case 2: delresources();break;case 3: changeresources();break;case 4: share();break;case 5: addprocess();break;case 0: choice=0;break;default: cout<<"请正确选择功能号(0-5)!"<<endl;break;}}return 1; }。

相关文档
最新文档