银行家算法---C++实现

众所周知的死锁避免的一个算法------银行家算法，它是根据当前系统的资源分配状态来判断本次资源请求是否合法，如果合法，就分配资源，否则就不分配资源，因为这可能会发生死锁状态。

下面我是我根据自己的理解的一个算法实现。欢迎大家指正。

#include<iostream>
using namespace std;

int Resource[3]={10,5,7};//三种资源数.
int Available[3];//可用资源数
int RequireMax[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};//5个进程，每个进程最多会申请的资源
int Allocation[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};//每个进程已被分配的资源数
int Need[5][3];//目前每个进程还需要的资源数

bool isChange=true;//记录是否找到一个还没有被释放的进程
int direction=1;//1向下，-1向上
int num[3];//接受申请资源数

//判断该状态是否合法
bool isSafeState(int Available[3],int Allocation[5][3],int Need[5][3])
{

	int count=0;//记录被释放的进程数.
	int i=0;
	int j=0;
	int tempAvailable[3];//防止修改状态
	memcpy(tempAvailable,Available,3*sizeof(int));

	bool isRelease[5];//判断进程是否已经被释放.
	memset(isRelease,0,5);	
	while(isChange)
	{
		isChange=false;//每次遍历将其置为false.

		if(direction==-1)//初始化i的位置
		{
			i=4;
			while(i>=0)
			{
				if(!isRelease[i])
					break;
				else
					--i;
			}
		}
		else
		{
			i=0;
			while(i<5)
			{
				if(!isRelease[i])
					break;
				else
					++i;
			}
		}

		bool flag=false;//判断是否可以回收资源的标志
		for(i;i>=0&&i<5;i+=direction)
		{
			if(!isRelease[i])
			{
				for(j=0;j<3;++j)
				{
					if(tempAvailable[j]>=Need[i][j])
						flag=true;
					else
					{
						flag=false;
						break;
					}
				}
				if(flag)
				{
					isChange=true;
					isRelease[i]=true;
					++count;
					cout<<"进程"<<i<<"	";
					for(j=0;j<3;++j)
					{
						tempAvailable[j]+=Allocation[i][j];
					}
				}

			}
			flag=false;
		}
		direction*=-1;
	}
	//还原现场..还原初始状态，防止本次判断影响下次判断.
	direction=1;
	isChange=true;
	if(count==5)
	{
		cout<<"安全的状态"<<endl;
		return true;		
	}
		
	else
	{
		cout<<" 不安全的状态"<<endl;
		return false;
	}
}

bool init()//判断初始状态是否合法..这里只判断了一部分..
{
	int i;
	int j;
	for(i=0;i<3;++i)
		Available[i]=Resource[i];
	for(i=0;i<3;++i)
	{
		for(j=0;j<5;++j)
		{
			Available[i]=Available[i]-Allocation[j][i];
			if(Available[i]<0)
			{
				cout<<"初始状态不合法"<<endl;
				return false;
			}
		}
	}
	
	for(i=0;i<5;++i)
	{
		for(j=0;j<3;++j)
		{
			Need[i][j]=RequireMax[i][j]-Allocation[i][j];
			if(Need[i][j]<0)	
			{
				cout<<"初始状态不合法"<<endl;
				return false;
			}
		}
	}
	cout<<"初始状态合法"<<endl;
	return true;
	
}
void main()
{
	if(!init())
		return;
	if(!isSafeState(Available,Allocation,Need))
		return;
	char c;
	
	while(1)
	{
		cout<<" 输入y进行资源分配,其他退出程序"<<endl;
		cin>>c;
		if(c=='y')
		{
			cout<<"请输入申请资源的进程号(0--4)"<<endl;
			int i;
			cin>>i;
			if(i>4||i<0)
			{
				cout<<"输入不合法"<<endl;
				continue;
			}
			cout<<"请输入"<<3<<"个申请资源数"<<endl;
			cin>>num[0]>>num[1]>>num[2];
			int j=0;
			bool flag=false;
			for(j=0;j<3;++j)
			{
				if(Available[j]>=num[j]&&num[j]<=Need[i][j])
				{
					flag=true;
				}
				else
				{
					flag=false;
					break;
				}
			}
			if(!flag)
			{
				cout<<"分配失败"<<endl;
				continue;
			}
			for(j=0;j<3;++j)
			{
				Available[j]-=num[j];
				Allocation[i][j]+=num[j];
				Need[i][j]-=num[j];
			}
			if(!isSafeState(Available,Allocation,Need))
			{
				cout<<"分配失败"<<endl;
				for(j=0;j<3;++j)
				{
					Available[j]+=num[j];
					Allocation[i][j]-=num[j];
					Need[i][j]+=num[j];
				}
			}
			else
				cout<<"分配成功"<<endl;
				
		}
		else
			break;
	}
}

测试用例是根据<<操作系统概念>>第七版给的。