银行家算法

我们可以把操作系统作为一个银行家。操作系统管理的资金相当于银行家的资源。过程向操作系统请求分配相当于用户资源,银行贷款。

为了保证资金的安全性,银行规定:

(1) 当资金客户最大需求不超过可用资金的银行家可以接受客户;

(2) 贷款,但贷款的总数不能超过最大需求量;

(3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;

(4) 当顾客得到所需的所有资金后,一定能在有限的时间里归还所有的资金.

银行家算法数据结构

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。   

4)需求矩阵Need。

  

这也是一个n×m的矩阵,用以表示每个进程尚需的各类资源数。假设Need[i,j]=K,则表示进程i还须要Rj类资源K个,方能完毕其任务。

  

Need[i,j]=Max[i,j]-Allocation[i,j]

算法 的实现

一、初始化

由用户输入数据,分别对可利用资源向量矩阵AVAILABLE 、 最大需求矩阵MAX 、分配矩阵ALLOCATION、 需求矩阵NEED 赋值。

二、银行家算法

在避免死锁的方法中。所施加的限制条件较弱,有可能获得令人惬意的系统性能。在该方法中把系统的状态分为安全状态和不安全状态。仅仅要能使系统始终都处于安全状态,便能够避免发生死锁。

银行家算法的基本思想是分配资源之前, 推断系统是否是安全的; 若是, 才分配。它是最具有 代表性的避免死锁的算法。

设进程cusneed 提出请求REQUEST [i] ,则银行家算法按例如以下规则进行推断。

(1) 假设REQUEST [cusneed] [i]<= NEED[cusneed][i] ,则转(2) ;否则。出错。

(2) 假设REQUEST [cusneed] [i]<= AVAILABLE[cusneed][i] ,则转(3) ;否则。出错。

(3) 系统试探分配资源。改动相关数据:

AVAILABLE[i]-=REQUEST[cusneed][i];

ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];

NEED[cusneed][i]-=REQUEST[cusneed][i];

(4) 系统运行安全性检查,如安全,则分配成立。否则试探险性分配作废,系统恢复 原状, 进程等待。

三、安全性检查算法

(1) 设置两个工作向量Work=AVAILABLE;FINISH

(2) 从进程集合中找到一个满足下述条件的进 程,

FINISH==false;

NEED<=Work;

如找到,运行(3) ; 否则,运行(4)

(3) 设进程获得资源。可顺利运行。直至完 成,从而释放资源。

Work+=ALLOCATION;

Finish=true;

GOTO 2

(4) 如全部的进程Finish= true ,则表 示安全。否则系统不安全。

操作系统安全状态和不安全状态:   

安全序列是指一个进程序列{P1。…,Pn}是安全的,假设对于每个进程Pi(1≤i≤n),它以后尚须要的资源量不超过系统当前剩余资源量与全部进程Pj (j < i )当前占有资源

量之和。

假设存在一个由系统中全部进程构成的安全序列P1。…,Pn,则系统处于安全状态。安全状态一定是没有死锁发生。

不存在一个安全序列。不安全状态不一定导致死锁。

各算法流程图

初始化算法流程图:

银行家算法流程图:

aid=271" target="_blank">

安全性算法流程 图:

aid=272" target="_blank">

源程序

#include <iostream>
using namespace std;
#define MAXPROCESS 50                        /*最大进程数*/
#define MAXRESOURCE 100                        /*最大资源数*/
int AVAILABLE[MAXRESOURCE];                    /*可用资源数组*/
int MAX[MAXPROCESS][MAXRESOURCE];            /*最大需求矩阵*/
int ALLOCATION[MAXPROCESS][MAXRESOURCE];    /*分配矩阵*/
int NEED[MAXPROCESS][MAXRESOURCE];            /*需求矩阵*/
int REQUEST[MAXPROCESS][MAXRESOURCE];        /*进程须要资源数*/
bool FINISH[MAXPROCESS];                        /*系统是否有足够的资源分配*/
int p[MAXPROCESS];                             /*记录序列*/
int m,n;                                    /*m个进程,n个资源*/
void Init();
bool Safe();
void Bank();
void showdata(int,int);
int main()
{
	Init();
	Safe();
	Bank();
}
void Init()                /*初始化算法*/
{
	int i,j;
	cout<<"请输入进程的数目:";
	cin>>m;
	cout<<"请输入资源的种类:";
	cin>>n;
	cout<<"请输入每一个进程最多所需的各资源数,依照"<<m<<"x"<<n<<"矩 阵输入"<<endl;
	for(i=0;i<m;i++)
		for(j=0;j<n;j++)
			cin>>MAX[i][j];
	cout<<"请输入每一个进程已分配的各资源数,也依照"<<m<<"x"<<n<<"矩 阵输入"<<endl;
	for(i=0;i<m;i++)
	{
		for(j=0;j<n;j++)
		{
			cin>>ALLOCATION[i][j];
			NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];
			if(NEED[i][j]<0)
			{
				cout<<"您输入的第"<<i+1<<"个进程所拥有的第"<<j+1<<"个资源数 错误,请又一次输入:"<<endl;
				j--;
				continue;
			}
		}
	}
	cout<<"请输入各个资源现有的数目:"<<endl;
	for(i=0;i<n;i++)
	{
		cin>>AVAILABLE[i];
	}
}
void Bank()                /*银行家算法*/
{
	int i,cusneed,flag = 0;
	char again;
	while(1)
	{
		showdata(n,m);////////////////////////////////////////////////////////////////////
		cout<<endl;
input:
		cout<<"请输入要申请资源的进程号(注:第1个进程号为0,依次类推)"<<endl;
		cin>>cusneed;
		if (cusneed > m)
		{
			cout<<"没有该进程。请又一次输入"<<endl;
			goto input;
		}
		cout<<"请输入进程所请求的各资源的数量"<<endl;
		for(i=0;i<n;i++)
		{
			cin>>REQUEST[cusneed][i];
		}
		for(i=0;i<n;i++)
		{
			if(REQUEST[cusneed][i]>NEED[cusneed][i])//假设用户选择的线程的第i个资源请求数>该线程该资源所需的数量
			{
				cout<<"您输入的请求数超过进程的需求量!请又一次输入!"<<endl;
				goto input;
			}
			if(REQUEST[cusneed][i]>AVAILABLE[i])//假设用户选择的线程的第i个资源请求数>系统现有的第i个资源的数量
			{
				cout<<"您输入的请求数超过系统有的资源数!请又一次输入!"<<endl;
				goto input;
			}
		}
		for(i=0;i<n;i++)//假设请求合理,那么以下
		{
			AVAILABLE[i]-=REQUEST[cusneed][i];//系统可用资源减去申请了的
			ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];//线程被分配的资源加上已申请了的
			NEED[cusneed][i]-=REQUEST[cusneed][i];//线程还须要的资源减去已申请得到的
		}
		if(Safe())//AVAILABLE  ALLOCATION  NEED变动之后。是否会导致不安全
		{
			cout<<"允许分配请求!"<<endl;
		}
		else
		{
			cout<<"您的请求被拒绝!"<<endl;
			for(i=0;i<n;i++)
			{
				AVAILABLE[i]+=REQUEST[cusneed][i];
				ALLOCATION[cusneed][i]-=REQUEST[cusneed][i];
				NEED[cusneed][i]+=REQUEST[cusneed][i];
			}
		}
		for (i=0;i<n;i++)
		{
			if (NEED[cusneed][i] <= 0)
			{
				flag++;
			}
		}
		if (flag == n)//假设该进程各资源都已满足条件。则释放资源
		{
			for (i=0;i<n;i++)
			{
				AVAILABLE[i] += ALLOCATION[cusneed][i];
				ALLOCATION[cusneed][i] = 0;
				NEED[cusneed][i] = 0;
			}
			cout<<"线程"<<cusneed<<" 占有的资源被释放!

"<<endl;
			flag = 0;
		}
		for(i=0;i<m;i++)//分配好了以后将进程的标识FINISH改成false
		{
			FINISH[i]=false;
		}
		cout<<"您还想再次请求分配吗?是请按y/Y,否请按其他键"<<endl;
		cin>>again;
		if(again==‘y‘||again==‘Y‘)
		{
			continue;
		}
		break;
	}
}
bool Safe()                                    /*安全性算法*/
{
	int i,j,k,l=0;
	int Work[MAXRESOURCE];                    /*工作数组*/
	for(i=0;i<n;i++)
		Work[i]=AVAILABLE[i];
	for(i=0;i<m;i++)
	{
		FINISH[i]=false;//FINISH记录每一个进程是否安全
	}
	for(i=0;i<m;i++)
	{
		for(j=0;j<n;j++)//循环查找第i个进程须要的各个资源数 是否 超过系统现有的相应的资源数
		{
			if(NEED[i][j]>Work[j])//第i个进程须要的第j个资源数 > 系统现有的第j个资源数
			{
				break;
			}
		}
		if(j==n)//假设第i个进程所需的各个资源数都没有超过系统现有的相应资源数
		{
			FINISH[i]=true;//给该进程的FINISH标记为true
			for(k=0;k<n;k++)
			{
				Work[k]+=ALLOCATION[i][k];//将Work赋值为 第i个进程各个已分配资源数+系统现有的相应资源数(由于当改进程所有资源数都满足时线程结束并将资源返还给系统)
			}
			p[l++]=i;//记录进程号
		}
		else//假设超过继续循环下一个进程
		{
			continue;
		}
		if(l==m)//当全部进程都可以被满足执行时
		{
			cout<<"系统是安全的"<<endl;
			cout<<"安全序列:"<<endl;
			for(i=0;i<l;i++)//改了146行的i值,显示资源分配给进程的顺序
			{
				cout<<p[i];
				if(i!=l-1)
				{
					cout<<"-->";
				}
			}
			cout<<""<<endl;
			return true;
		}
	}//for循环
	cout<<"系统是不安全的"<<endl;
	return false;
}

void showdata(int n,int m)   //显示
{
	int i,j;
	cout<<endl;
	cout<<"-------------------------------------------------------------"<<endl;
	cout<<"系统可用的资源数为:    ";
	for   (j=0;j<n;j++)
		cout<<"    "<<AVAILABLE[j];
	cout<<endl;
	cout<<"各进程还须要的资源量:"<<endl;
	for   (i=0;i<m;i++)
	{
		cout<<"    进程"<<i<<":";   

		for   (j=0;j<n;j++)
			cout<<"     "<<NEED[i][j];
		cout<<endl;
	}   

	cout<<endl;
	cout<<"各进程已经得到的资源量:    "<<endl<<endl;   

	for   (i=0;i<m;i++)
	{
		cout<<"    进程"<<i<<":";   

		for   (j=0;j<n;j++)
			cout<<"     "<<ALLOCATION[i][j];
		cout<<endl;
	}
	cout<<endl;
}   


				
时间: 2025-01-03 05:01:26

银行家算法的相关文章

银行家算法 C++实现

操作系统中预防死锁的银行家算法,测试用例来自<计算机操作系统(第四版)>113页例题. #include<iostream> #include<cstdio> #include<cstring> #include<cstdlib> #define Process_Max 100 //进程数量最大值 #define Resource_Max 100 //资源种类最大值 using namespace std; int Available[Resou

操作系统—银行家算法

参考http://blog.csdn.net/yaopeng_2005/article/details/6935235 对小鹏_加油的代码进行了部分修改,并加入了自己的文档注释 定义全局变量,以及主函数main 1 #include <iostream> 2 using namespace std; 3 #define MAXPROCESS 50 //最大进程数 4 #define MAXRESOURCE 100 //最大资源数 5 int AVAILABLE[MAXRESOURCE]; //

C语言实现 操作系统 银行家算法

嘿嘿,今晚心血来潮,在宿舍把银行家算法实现了. /************************************************** 银行家算法: 主要的思想是 舍大取小,先满足小的,最后才满足大的. author: lyb date: 2014/10/15 ***************************************************/ #include <stdio.h> #include <stdlib.h> #include <

操作系统之银行家算法

一.需求分析 1.进程的状态有:就绪,等待和完成.当系统不能满足进程的资源请求时,进程出于等待状态.资源需求总量表示进程运行过程中对资源的总的需求量.已占资源量表示进程目前已经得到但还为归还的资源量.因此,进程在以后还需要的剩余资源量等于资源需要总量减去已占资源量.陷入每个进程的资源需求总量不应超过系统拥有的资源总量. 2.银行家算法分配资源的原则是:当某个进程提出资源请求时,假定先分配资源给它,然后查找各进程的剩余请求,检查系统的剩余资源量是否由于进程的分配而导致系统死锁.若能,则让进程等待,

避免死锁的银行家算法C++程序实现

 本篇博文为追忆曾经写过的算法系列第二篇(20081021) 温故知新 目的:具有代表性的死锁避免算法是Dijskstra给出的银行家算法.本实验是基于银行家算法的思想通过编写C++程序实现银行家算法的计算机程序化,使其更实用.同时也加深了有关自愿申请.避免死锁等概念,体会避免死锁的实际实现过程与方法. 要求: 1.设定进程p对各类资源r合理的最大需求max及初值确定:2.设定系统提供资源初始状况allocation:3.设定每次某个进程对各类资源的申请表示need:4.编制C++程序,基于

银行家算法java实现

关于银行家算法的理论知识,课本或者百度上有好多资料,我就不再多说了,这里把我最近写的银行家算法的实现带码贴出来. 由于这是我们的一个实验,对系统资源数和进程数都指定了,所以这里也将其指定了,其中系统资源数为3,进程数为5. import java.util.Scanner; import javax.swing.plaf.basic.BasicInternalFrameTitlePane.MaximizeAction; import javax.swing.text.StyledEditorKi

[OS] 死锁相关知识点以及银行家算法详解

因此我们先来介绍一下死锁: 死锁特征 当出现死锁时,进程永远不能完成,并且系统资源被阻碍使用,阻止了其他作业开始执行.在讨论处理死锁问题的各种方法之前,先深入讨论一下死锁的特征. ·必要条件 (1)互斥:至少有一个资源必须处于非共享模式,即一次只有一个进程使用.如果另一进程申请该资源,那么申请进程必须等到该资源被释放为止. (2)占有并等待:一个进程必须占有至少一个资源,并等待另一资源,而该资源为其他进程所占有. (3)非抢占:资源不能被抢占,即资源只能在进程完成任务后自动释放. (4)循环等待

银行家算法——软考探究(四)

著名的银行家算法,最早是由Dijkstra提出来的.它是一种最有代表性的避免死锁的算法.在避免死锁方法中允许进程动态地申请资源,但系资源分配之前,应先计算此次分配资源的安全性,若分配不会导致系统进入不安全状态,则分配,否则等待. 银行家算法最重要的就是判断是可用资源和仍需资源之间的关系,如果可用资源数大于人需资源数,那么我们认为这个进程就是可以执行的,也是安全的,反之,便是不安全的.所以重中之重的是找到各种资源数. 对进程的判断遵循以下步骤: 1.计算系统开始时所有的资源数,即开始的可用资源数;

死锁的避免——银行家算法

银行家把一定数量的资金供多个用户周转使用.当顾客对资金的最大申请量不超过银行家现金时,就可接纳一个新顾客:顾客可以分期借款:但借款总数不能超过最大申请量:银行家对顾客的借款可以推迟支付,但一定是顾客总能在有限的时间里得到借款:当顾客得到全部资金后,他一定能在有限时间里面归还所有资金. 采用银行家算法分配资源时候,测试进程对资源的最大需求量,如果系统现存的资源可以满足他的最大需求量时,就满足进程当前的申请,否则就推迟分配.这样做,能保证至少有一个进程可得到需要的全部资源而执行到结束,然后归还资源供