银行家算法
银行家算法总结

银行家算法总结银行家算法是一种经典的避免死锁的算法,在操作系统中得到了广泛的应用。
本文将对银行家算法进行总结,介绍其原理和应用。
## 1. 银行家算法简介银行家算法是一种资源分配和安全性检查的算法,用于避免在多个进程竞争有限资源时产生死锁。
它通过预先分配资源,检查每个进程请求资源后是否会导致系统进入不安全状态,从而避免死锁的发生。
## 2. 银行家算法原理银行家算法基于以下前提条件和原理:- 每个进程对资源的最大需求量是固定的,并在程序开始时规定。
- 系统中的资源被分为多类,每类资源的数目也是固定的。
- 每个进程在请求资源时需要指定所需资源的数量。
- 当进程请求资源时,系统会先检查此次请求是否安全,如果安全则分配资源,否则将此次请求置于等待状态。
银行家算法的原理可以归纳为以下几个步骤:1. 初始化阶段:系统初始化可分配资源和进程的最大需求量,并记录当前已分配资源和已请求资源的情况。
2. 请求资源阶段:当进程请求资源时,系统首先判断此次请求是否会导致系统进入不安全状态。
3. 安全检查阶段:系统通过安全性检查算法,判断当前系统状态下是否有足够的资源分配给进程,避免产生死锁。
4. 分配资源阶段:如果系统通过安全检查,则分配资源给进程,并将进程从等待状态转换为运行状态。
5. 进程释放资源:当进程完成任务后,释放已分配的资源。
6. 终止进程阶段:在释放资源后,检查是否有其他进程的请求可以被满足,如果满足则继续分配资源。
## 3. 银行家算法应用场景银行家算法主要应用于多进程共享有限资源的场景,如操作系统、数据库管理系统等。
以下是一些常见的应用场景:1. 操作系统资源管理:在多任务操作系统中,为了确保资源的高效利用,避免死锁的发生,可以使用银行家算法进行资源分配和调度。
2. 分布式系统:在分布式系统中,各个节点之间可能存在资源争用的情况。
使用银行家算法可以保证资源的分配和调度是安全的,避免死锁和资源竞争。
3. 并发编程:在并发编程中,多个线程可能会竞争同一资源。
银行家算法课件

我们可以把操作系统看作是银行家,操作系统管 理的资源相当于银行家管理的资金,进程向操作系统 请求分配资源相当于用户向银行家贷款。操作系统按 照银行家制定的规则为进程分配资源,当进程首次申 请资源时,要测试该进程对资源的最大需求量,如果 系统现存的资源可以满足它的最大需求量则按当前的 申请量分配资源,否则就推迟分配。当进程在执行中 继续申请资源时,先测试该进程已占用的资源数与本 次申请的资源数之和是否超过了该进程对资源的最大 需求量。若超过则拒绝分配资源,若没有超过则再测 试系统现存的资源能否满足该进程尚需的最大资源量, 若能满足则按当前的申请量分配资源,否则也要推迟 分配。
2,0,1,2
P4
4,3,6,6
P5
4,6,9,8
• P5执行后,不能继续执行下去,则该状态不安全,系统将拒绝资源请求。
1.4银行家算法的实现
1.3银行家算法
3) Work:=Work+Allocation[i]; Finish[i]:=true; 转(1)
(4) 若对所有i,Finish[i]=true,则系统处 于安全状态,否则处于不安全状态
1.3银行家算法
例题:假设某系统中有4个 资源(R1、R2、R3、R4), 在某个时刻系பைடு நூலகம்中共有5个
进程等待
1.3银行家算法
为进行安全性检查,定义数据结构: Work:ARRAY[1..m] of integer; Finish:ARRAY[1..n] of Boolean; 安全性检查的步骤: (1) Work:=Available;
Finish:=false; (2) 寻找满足条件的i:
a.Finish[i]=false; b.Need[i]≤Work; 如果不存在,则转(4)
简述银行家算法

简述银行家算法银行家算法,也称为银行家安全算法,是一种用于避免系统资源的死锁现象的算法。
在操作系统中,当多个进程需要同时访问同一组资源并且它们的访问不可分割时,就会产生死锁现象。
在这种情况下,所有的进程都会被阻塞,无法进行任何工作。
银行家算法通过对系统资源的分配和管理,可以避免死锁现象的发生。
它主要包括以下几个步骤:1. 初始化系统:在系统启动时,需要确定每种类型的资源的数量和可用数量,并记录每个进程需要的最大资源数和已经分配的资源数。
2. 进行资源请求:当一个进程需要资源时,会向系统发送一个资源请求。
该请求指定了进程需要的资源类型和数量。
如果系统中有足够的资源可以分配给该进程,那么分配成功并将资源分配给该进程。
3. 检查资源分配是否安全:在分配资源之前,需要检查分配后系统是否处于安全状态。
安全状态是指在分配后,所有进程都能够完成它们的工作并释放所有资源。
如果系统处于安全状态,则分配资源并通知进程可以执行它们的任务。
4. 回收资源:当进程完成任务后,会释放它所占用的所有资源并通知系统。
系统会将这些资源重新分配给其他进程。
在银行家算法中,对于每个进程,都会维护一个资源请求向量和一个安全向量。
资源请求向量包含了进程当前所需要的资源数量,安全向量包含了系统中未分配的资源数量。
当系统收到一个资源请求时,会将该请求向量加入到系统资源向量中,并检查是否存在一个安全序列,该安全序列满足所有进程都可以完成它们的任务并释放它们所占用的所有资源。
如果存在这样的安全序列,则分配资源并通知进程可以执行它们的任务;如果不存在,则拒绝资源请求并等待其他进程的资源释放。
通过使用银行家算法,可以避免系统中的死锁现象,保证所有进程都可以完成它们的任务。
这种算法被广泛应用于操作系统和其他复杂的软件系统中,是保障系统安全性的重要工具。
银行家算法及流程图

(3)系统试探分配资源,修改相关数据:
AVAILABLE[i]-=REQUEST[cusneed][i];
ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];
Bank();
}
void Init() /*初始化算法*/
{
int i,j;
cout〈〈”请输入进程的数目:";
cin〉>m;பைடு நூலகம்
cout〈<"请输入资源的种类:”;
cin〉〉n;
cout<<"请输入每个进程最多所需的各资源数,按照"〈<m<〈"x”<<n〈〈”矩阵输入"〈〈endl;
for(i=0;i<m;i++)
}
for(i=0;i<m;i++)
{
if(FINISH[i]==true)
{
continue;
}
else
{
for(j=0;j〈n;j++)
{
if(NEED[i][j]>Work[j])
{
break;
}
}
if(j==n)
{
FINISH[i]=true;
for(k=0;k〈n;k++)
{
Work[k]+=ALLOCATION[i][k];
NEED[cusneed][i]-=REQUEST[cusneed][i];
银行家算法总结

银行家算法总结一、银行家算法银行家算法(Banker’s Algorithm),又称银行家管理算法,是一种专门用于系统资源管理的算法,用于解决操作系统中多个用户对多类资源的竞争请求,从而保证合理地分配公共资源,解决资源分配问题,其目的是为了保证单个进程的安全运行,同时保证系统的安全运行。
二、银行家算法的定义银行家算法是一种用于解决多个用户对多类资源的竞争请求的算法,也称作资源分配算法或资源管理算法,它可以确定是否有足够的资源可供一个或多个进程安全运行,如果有足够的资源可供运行,则可以分配该资源,否则系统将进入不满足安全状态。
三、银行家算法的特点(1)安全性:银行家算法可以确定是否有足够的资源可以满足所有进程的最大要求,使系统处于安全态;(2)在安全态下,银行家算法能够有效地检查一个进程是否可以获得资源,并且可以确定该状态下的最优解;(3)银行家算法可以有效检查一个系统是否处于安全态,它可以检查任意多个资源种类的一组资源分配是否安全;(4)银行家算法可以防止死锁的发生,可以有效地确保非抢占式多处理机系统的安全运行;(5)银行家算法设计简单,容易实现,并十分快速;(6)银行家算法不是最优的,它只是一种有效的搜索算法,其实现效率较低;四、银行家算法的使用1、资源分配问题银行家算法可以用于操作系统中的多个用户对多类资源的竞争请求,以此保证资源的合理分配,从而解决资源分配问题。
它可以有效地检查一个进程是否可以获得资源,同时可以确定该状态下的最优解。
2、进程安全性银行家算法可以用于检查一个系统是否处于安全态,并检查任意多个资源种类的一组资源分配是否安全,可以保证系统的安全运行,从而保证单个进程的安全性。
3、防止死锁银行家算法可以防止死锁的发生,这是由于它可以确定是否有足够的资源可以满足所有进程的最大要求,使系统处于安全态,从而阻止死锁发生。
总结银行家算法的算法思想

总结银行家算法的算法思想银行家算法(Banker's algorithm)是一种用于避免死锁的资源分配算法。
它是由荷兰计算机科学家埃德赫尔特·迪科斯彻在1965年提出的,其核心思想是通过判断系统状态是否安全来避免资源分配导致的死锁。
银行家算法的基本思想是在进行资源分配之前,通过模拟执行来判断系统是否会进入不安全状态。
具体来说,该算法需要维护一些数据结构,包括进程的最大需求矩阵、已分配资源矩阵、可用资源矩阵和需求资源矩阵。
通过这些矩阵的计算和比较,可以判断出系统是否能够分配资源,并避免死锁情况的出现。
银行家算法的算法过程如下:1. 初始化:将进程的最大需求矩阵、已分配资源矩阵、可用资源矩阵和需求资源矩阵进行初始化。
2. 安全性检查:通过循环遍历每个进程,判断当前系统状态是否安全。
具体的判断标准是,判断每个进程的需求资源矩阵是否小于等于可用资源矩阵,若满足条件,则代表该进程可以执行,否则代表该进程无法执行。
3. 执行分配:如果当前系统状态安全,则将资源分配给进程执行,并更新已分配资源矩阵和可用资源矩阵。
4. 释放资源:当进程执行完毕后,释放已占有资源,并更新已分配资源矩阵和可用资源矩阵。
银行家算法的核心思想是通过安全性检查来避免死锁的发生。
在进行资源分配之前,系统会先进行模拟执行,判断系统状态是否安全。
如果系统是安全的,则资源会分配给进程执行;否则,资源不会分配,并保持当前状态。
这样可以防止资源的过度分配和不合理分配,进而减少死锁的发生。
银行家算法的优点是避免了资源的浪费和不合理分配,保证了系统的高效运行。
同时,该算法也能够避免死锁的产生,提高了系统的稳定性和可靠性。
然而,银行家算法也存在一些局限性。
首先,该算法要求进程提前声明对资源的最大需求,而实际情况下,有些进程可能无法准确地预先声明自己的资源需求。
其次,该算法需要维护多个矩阵,增加了算法的复杂性和计算量。
最后,银行家算法只是一种静态的资源分配算法,无法适应动态变化的系统需求。
银行家算法
银行家算法一、基本思想:银行家算法是最具有代表性的避免死锁的算法,在本实验中是用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();}}}}}}三、实验结果截图:。
避免死锁的一个著名算法
避免死锁的一个著名算法是:银行家算法。
四个条件:
1、分批向银行贷款时,申请的总额不能超过一开始申请的额度;
2、申请贷款时不能超过银行现有资金数目;
3、当银行资金不能满足顾客贷款需求时,可以推迟支付,但是肯定会让顾客在需求时间内得到贷款;
4、顾客拿到贷款后必须在规定时间内归还。
银行家算法(Banker's Algorithm)是一个避免死锁(Deadlock)的著名算法,是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。
它以银行借贷系统的分配策略为基础,判断并保证系统的安全运行。
在银行中,客户申请贷款的数量是有限的,每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量,在满足所有贷款要求时,客户应及时归还。
银行家在客户申请的贷款数量不超过自己拥有的最大值时,都应尽量满足客户的需要。
在这样的描述中,银行家就好比操作系统,资金就是资源,客户就相当于要申请资源的进程。
银行家算法是一种最有代表性的避免死锁的算法。
在避免死锁方法中允许进程动态地申请资源,但系统在进行资源分配之前,应先计算此次分配资源的安全
性,若分配不会导致系统进入不安全状态,则分配,否则等待。
为实现银行家算法,系统必须设置若干数据结构。
要解释银行家算法,必须先解释操作系统安全状态和不安全状态。
安全序列是指一个进程序列{P1,…,Pn}是安全的,即对于每一个进程
Pi(1≤i≤n),它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
计算机操作系统银行家算法
计算机操作系统必考题(银行家算法) 银行家算法( banker's algorithm )由 Dijkstra于1965提出,关键是将死锁的问题演示为一个银行家贷款的模型,由于能用于银行系统的现金贷款而出名。
一个银行家向一群客户发放信用卡,每个客户有不同的信用额度。
每个客户可以提出信用额度内的任意额度的请求,直到额度用完后再一次性还款。
银行家承诺每个客户最终都能获得自己需要的额度。
所谓“最终”,是说银行家可以先挂起某个额度请求较大的客户的请求,优先满足小额度的请求,等小额度的请求还款后,再处理挂起的请求。
这样,资金能够永远流通。
所以银行家算法其核心是:保证银行家系统的资源数至少不小于一个客户的所需要的资源数。
银行家算法是一种最有代表性的避免死锁的算法。
在避免死锁方法中允许进程动态地申请资源,但银行家算法在系统在进行资源分配之前(并不是真的不分配,这样就没法做了,只不过是试探性分配,不满足的话再恢复),应先计算此次分配资源的安全性,若分配不会导致系统进入不安全状态,则分配,否则等待。
为实现银行家算法,系统必须设置若干数据结构。
要解释银行家算法,必须先解释操作系统安全状态和不安全状态。
安全序列是指存在一个进程序列{P1,…,Pn}是安全的,不会死锁(至少两个线程占有某资源A,但是都不满足,剩余的资源A分配给谁仍然无法满足),安全状态如果存在一个由系统中所有进程构成的安全序列P1,…,Pn,则系统处于安全状态,安全状态一定是没有死锁发生;不安全状态不存在一个安全序列,不安全状态不一定导致死锁。
本算法在理论上是出色的,能非常有效地避免死锁,但从某种意义上说,它缺乏实用价值,因为很少有进程能够在运行前就知道其所需资源的最大值,且进程数也不是固定的,往往在不断地变化(如新用户登录或退出),况且原来可用的资源也可能突然间变成不可用(如打印机、磁带机可能被损坏)。
二.算法原理银行家算法的基本思想是分配资源之前,判断系统是否是安全的;若是,才分配。
深入解析银行家算法
深入解析银行家算法银行家算法是一种用于多进程系统的资源分配和调度算法,目的是确保系统中的各个进程能够安全地访问所需的资源,且不会发生死锁(Deadlock)的情况。
本文将深入解析银行家算法的工作原理和应用。
1. 背景和定义:银行家算法最初由Dijkstra提出,用于解决多进程系统中资源分配的问题。
它基于银行家和客户的关系类比,将系统中的资源视为银行家的资金,将进程视为客户。
银行家必须合理分配资金,以避免资金不足导致系统中的进程无法完成任务。
2. 原理:银行家算法运用了安全性检查(safety check)和资源分配策略。
安全性检查是通过模拟资源分配的情况,判断系统是否处于安全状态,即不存在死锁,可以继续分配资源。
资源分配策略是根据安全性检查的结果,将资源分配给请求资源的进程,确保系统安全性。
3. 数据结构:银行家算法使用以下数据结构:进程的最大需求矩阵(Maximum),系统已分配资源矩阵(Allocation),系统可用资源向量(Available),进程的尚需资源矩阵(Need)。
这些数据结构可以反映每个进程对每种资源的需求量、已分配量和尚需量。
4. 算法流程:银行家算法的流程如下:- 系统初始化:将每个进程的最大需求矩阵、已分配资源矩阵和系统可用资源向量初始化。
- 请求资源:当某个进程请求资源时,首先检查该请求是否超出了其最大需求量和系统可用资源量,如果超出则拒绝请求;否则进入下一步。
- 模拟分配:假设分配资源给该进程,更新进程的已分配资源矩阵和系统可用资源向量。
- 安全性检查:检查系统是否处于安全状态,即不存在死锁。
该检查基于银行家算法的安全性条件,即每个进程的尚需资源量可以得到满足。
- 分配或回滚:如果安全性检查通过,则进程得到资源分配,否则回滚分配过程,恢复之前的状态。
5. 应用场景:银行家算法广泛应用于操作系统中,尤其是在多任务和多进程环境下。
它可以帮助确定是否可以分配资源给某个进程,以避免资源竞争和死锁的问题。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
操作系统原理课程设计课程名称:死锁的避免;模拟银行家算法专业班级:14级信管2班组长:赵贤杰成员:云靖宿熙隆指导教师:付维娜2016 / 2017 学年第 2 学期【设计题目】死锁的避免;银行家算法【设计目标】(1)进一步理解利用银行家算法避免死锁的问题;(2)在了解和掌握银行家算法的基础上,编制银行家算法通用程序,将调试结果显示在计算机屏幕上,再检测和笔算的一致性。
(3)理解和掌握安全序列、安全性算法(4)了解和理解死锁;(5)理解利用银行家算法避免死锁的原理;(6)会使用某种编程语言。
【设计原理】一、安全状态指系统能按照某种顺序如<P1,P2,…,Pn>(称为<P1,P2,…,Pn>序列为安全序列),为每个进程分配所需的资源,直至最大需求,使得每个进程都能顺利完成。
二、银行家算法假设在进程并发执行时进程i提出请求j类资源k个后,表示为Requesti[j]=k。
系统按下述步骤进行安全检查:如果Requesti≤Needi则继续以下检查,否则显示需求申请超出最大需求值的错误。
如果Requesti≤Available则继续以下检查,否则显示系统无足够资源,Pi阻塞等待。
(3)系统试探着把资源分配给进程Pi,并修改下面数据结构中的数值:Available[j]∶=Available[j]-Requesti[j];Allocation[i,j]∶=Allocation[i,j]+Requesti[j];Need[i,j]∶=Need [i,j]-Requesti[j];(4)系统执行安全性算法,检查此次资源分配后,系统是否处于安全状态。
若安全,才正式将资源分配给进程Pi,以完成本次分配;否则,将本次的试探分配作废,恢复原来的资源分配状态,让进程Pi 等待。
三、安全性算法设置两个向量:∶工作向量Work:它表示系统可提供给进程继续运行所需的各类资源数目,它含有m个元素,在执行安全算法开始时,Work∶=Available;∶Finish:它表示系统是否有足够的资源分配给进程,使之运行完成。
开始时先做Finish[i]∶=false;当有足够资源分配给进程时,再令Finish[i]∶=true。
从进程集合中找到一个能满足下述条件的进程:∶Finish[i]=false;∶Need[i,j]≤Work[j];若找到,执行步骤(3),否则,执行步骤(4)。
(3)当进程Pi获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:Work[j]∶=Work[i]+Allocation[i,j];Finish[i]∶=true;go to step2;(4)如果所有进程的Finish[i]=true都满足,则表示系统处于安全状态;否则,系统处于不安全状态。
【设计内容和步骤】1.流程图(1)参考下图所示流程图编写安全算法。
(2)编写统一的格式。
每次提出申请之后输出申请成功与否的结果。
如果成功还需要输出变化前后的各种数据,并且输出安全序列。
(3)参考下图所示流程图编写银行家算法。
(4)编写主函数来循环调用银行家算法。
2.运行效果截图【设计总结】1.通过本次银行家算法实验,加深了我们对银行家算法的了解,掌握了如何利用银行家算法避免死锁。
2.实验中遇到点问题,通过查阅资料、询问老师顺利解决。
3.通过这次的实践,使我们理论知识更加的牢固。
【参考文献】1.汤小凤,梁红兵.计算机操作系统,西安:西安电子科技大学出版社,20022.王清,李光明.计算机操作系统,北京:冶金工业出版社,2003【程序代码】#include <iostream.h>#include <string.h>#define M 3 //资源的种类数#define N 5 //进程的个数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]);void main(){int i,j;//当前可用每类资源的资源数int iAvailable[M]={3,3,2};//系统中N个进程中的每一个进程对M类资源的最大需求int iMax[N][M]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//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为否。
\n";cin>>ch;switch(ch){case 'y'://cout<<"调用银行家算法";bSafe=banker(iAllocation,iNeed,iAvailable,cName);if (bSafe) //安全,则输出变化后的数据output(iMax,iAllocation,iNeed,iAvailable,cName);break;case 'n':cout<<"退出。
\n";bExitFlag=false;break;default:cout<<"输入有误,请重新输入:\n";}}}//输出void output(int iMax[N][M],int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]){int i,j;cout<<"\n\t Max \tAllocation\t Need \t Available"<<endl;cout<<"\tA B C\tA B C\tA B C\t A B C"<<endl;for(i=0;i<N;i++){cout<<cName[i]<<"\t";for(j=0;j<M;j++)cout<<iMax[i][j]<<" ";cout<<"\t";for(j=0;j<M;j++)cout<<iAllocation[i][j]<<" ";cout<<"\t";for(j=0;j<M;j++)cout<<iNeed[i][j]<<" ";cout<<"\t";cout<<" ";//Available只需要输出一次if (i==0)for(j=0;j<M;j++)cout<<iAvailable[j]<<" ";cout<<endl;}}//安全性算法,进行安全性检查;安全返回true,并且输出安全序列,不安全返回false,并输出不安全的提示;bool safety(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]){int i,j,flag,x=0;char num[5];int Work[M];bool Finish[N]; //定义基本变量for(j=0;j<3;j++)Work[j]=iAvailable[j]; //将iAvailable的值赋给Workfor(i=0;i<5;i++) //将Finish全部置为FalseFinish[i]=false;while(true) //执行无限循环,满足条件时跳出{flag=0; //每次循环开始时将记录本次循环中是否有使有满足条件iAllocation的标志置为0,若为0表示不存在,若不为0表示存在for(i=0;i<5;i++) //执行循环,看有没有满足条件的iAllocation{if(Finish[i]==false&&Work[0]>=iNeed[i][0]&&Work[1]>=iNeed[i][1]&&Work[2]>=iNeed[i ][2]){for(j=0;j<3;j++){Work[j]+= iAllocation[i][j] ; //Work[j]+= Work[j]+iAllocation[i][j] }Finish[i]=true; //将Finish置trueflag++; //标志加1num[x++]=cName[i]; //将该序列名赋给数组num[] }}if(flag==0){cout<<"无安全序列"; //标志为0,证明已无满足条件iAllocation ,退出循环,返回falsereturn false;}if(Finish[0]==true&&Finish[1]==true&&Finish[2]==true&&Finish[3]==true&&Finish[4]== true) //若所有Finish置为true,输出安全数列,返回True {cout<<"\n";cout<<"安全序列为:";for(x=0;x<5;x++)cout<<num[x]<<" ";cout<<"\n";return true;}}return true;}//安全返回true,不安全返回falsebool banker(int iAllocation[N][M],int iNeed[N][M],int iAvailable[M],char cName[N]){int iMax[N][M]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};int t,i,Request[3],check_1[3];char x; //定义变量cout<<"请输入进程名:"; //输入进程名cin>>x;if(x=='a')i=0;if(x=='b')i=1;if(x=='c')i=2;if(x=='d')i=3;if(x=='e')i=4;cout<<"请输入各资源数量:"; //输入变量名for(t=0;t<3;t++)cin>>Request[t];for(t=0;t<3;t++) //检查数值{check_1[t]=Request[t]+iAllocation[i][t];}for(t=0;t<3;t++){if((iMax[i][t]-check_1[t])<0){cout<<"\n资源申请超过最大需求量!!!\n";return false;}}for(t=0;t<3;t++) //检查数值{if((iAvailable[t]-Request[t])<0){cout<<"\n不能满足进程!!!\n";return false;}}for(t=0;t<3;t++) //将该变量的iAvailable、iAllocation、iNeed重新赋值{iAvailable[t]-=Request[t];iAllocation[i][t]+=Request[t];iNeed[i][t]-=Request[t];}safety(iAllocation,iNeed,iAvailable,cName); //执行安全数列算法return true;return true;}。