操作系统实验 银行家算法 避免死锁

银行家算法（避免死锁算法）

1.算法描述

银行家算法中数据结构如下：
n ：系统中的进程个数；
m ：系统中的资源类数。

• 1）Available（m）：现有资源向量。

Available（j）=k表示k个未分配的j类资源

• 2）Max（n，m）：资源最大申请量矩阵。

Max（i，j）=k表示第i个进程在运行过程中对第j类资源的最大申请量为k。

• 3）Allocation（n，m）：资源分配矩阵。

Allocation(i,j)=k表示进程i已占有k个j类资源。

• 4）Need（n，m）：进程以后还需要的资源矩阵。

Need（i，j）=k表示进程i以后还需要k个第j类资源。
显然有Need[i,j]=Max[i,j]-Allocation[i,j]。

• 5）Request（n，m）：进程申请资源矩阵。

Request（i，j）=k表示进程i申请k个第j类资源。

2.银行家算法思想如下：

若进程i申请资源，申请资源向量为Request（i），则有如下资源分配过程：

1）	如果Request（i）〉Need（i），则报错返回。
2）	如果Request（i）〉Avaliable，则进程i进入等待资源状态，返回。
3）	假设进程进程i的申请已获批准，于是尝试修改系统状态：
Avaliable=Avaliable-Request（i）
Allocation（i）=Allocation（i）+Request（i）
Need（i）=Need（i）-Request（i）
4）	调用安全状态检查算法。
设Work（m）为临时工作向量。初始时Work=Available。令N={1，2，……n}（N即表示进程未执行完的个数）。
A）	寻求j∈N 使其满足：Need（j）<=Work，若不存在这样的j则转至3）步。
B）	程序执行后释放资源：work=Work+Allocation（j）  N=N-{j}，转至1）步，循环该进程集合）。
C）	如果N=空集 则返回（系统安全，即书本上的所有进程的Finish[i] = true都满足）。
如果N≠空集 则返回（系统不安全）。
5）	若系统处于安全状态，则将进程i申请的资源分配给进程i，返回。
6）	若系统处于不安全状态，则不将进程i申请的资源分配给进程i，恢复原来的资源分配状态，让进程i等待。
Avaliable = Avaliable + Request（i）
Allocation（i）=Allocation（i）-Request（i）
Need（i）=Need（i）+ Request（i）

程序源代码

#include <iostream>
using namespace std;
#define False 0
#define True 1

int Max[100][100]={0};
int Allocation[100][100]={0};
int Need[100][100]={0};
int Available[100]={0};
int Work[100]={0};
char name[100]={0};
int temp[100]={0};
int S=100,P=100;
int safequeue[100]={0};
int Request[100]={0};

void Showdata()
{
	int i,j,k,l;
	cout<<"\t资源分配情况\n"<<endl;
	cout<<"\tMax"<<"\t已分配"<<"\tNeed"<<endl;
	cout<<"\t";
	for(j=0;j<3;j++)
	{
		for (i=0;i<S;i++)
		{
			cout<<name[i]<<" ";
		}
		cout<<"\t";
	}
	cout<<endl;
	for(i=0;i<P;i++)
	{
		cout<<i<<"\t";
		for (j=0;j<S;j++)
		{
			cout<<Max[i][j]<<" ";
		}
		cout<<"\t";
		for (k=0;k<S;k++)
		{
			cout<<Allocation[i][k]<<" ";
		}
		cout<<"\t";
		for (l=0;l<S;l++)
		{
			cout<<Need[i][l]<<" ";
		}
		cout<<endl;
	}
	cout<<"\nAvailable"<<endl;
	for (i=0;i<S;i++)
	{
		cout<<name[i]<<" ";
	}
	cout<<endl;
	for (i=0;i<S;i++)
	{
		cout<<Available[i]<<" ";
	}
	cout<<endl;
}

int Judgesafe()
{
	int tempwork[100][100]={0};
	int i,k=0,m,apply,Finish[100]={0};
	int j;
	int flag=0;
	for (i=0;i<S;i++)
	{
		Work[i]=Available[i];
	}
	for(i=0;i<P;i++)
	{ 
		apply=0;
		for(j=0;j<S;j++)
		{
			if (Finish[i]==False&&Need[i][j]<=Work[j])
			{   
				apply++;
				if(apply==S)
				{
					for(m=0;m<S;m++)
					{
						tempwork[i][m]=Work[m];
						Work[m]=Work[m]+Allocation[i][m];
					}
					Finish[i]=True;
					temp[k]=i;
					i=-1; 
					k++;
					flag++;
				}
			}
		}
	}
	for(i=0;i<P;i++)
	{
		if(Finish[i]==False)
		{
			cout<<"系统不安全"<<endl;
			return -1;
		}
	}
    cout<<"系统是安全的"<<endl;
    cout<<"分配的序列:";
	for(i=0;i<P;i++)
	{
		cout<<temp[i];
		if(i<P-1) cout<<"->";
	}
	cout<<endl;
    return 0;
}

void Changedata(int flag)
{
	for (int i=0;i<S;i++)
	{
		Available[i]=Available[i]-Request[i];
		Allocation[flag][i]=Allocation[flag][i]+Request[i];
		Need[flag][i]=Need[flag][i]-Request[i];
	}
}

void Share()
{
	int i,flag;
	char ch='Y';
	cout<<"输入请求资源的进程："<<endl;
	cin>>flag;
	if (flag>=P)
	{
		cout<<"此进程不存在!"<<endl;
	}
	else
	{
		cout<<"输入此进程对各个资源的请求数量："<<endl;
		for (i=0;i<S;i++)
		{
			cin>>Request[i];
		}
		for (i=0;i<S;i++)
		{
			if (Request[i]>Need[flag][i])
			{
				cout<<"进程"<<flag<<"申请的资源大于它所需要的资源!"<<endl;
				cout<<"分配不合理不予分配!"<<endl;
				ch='N';
				break;
			}
			else if (Request[i]>Available[i])
			{
				cout<<"进程"<<flag<<"申请的资源大于可利用的资源。"<<endl;
				cout<<"分配不合理，不予分配!"<<endl;
				ch='N';
				break;
			}
		}
		if (ch=='Y')
		{
			Changedata(flag);
			if (Judgesafe()==-1)
			{
				cout<<"进程"<<flag<<"申请资源后，系统进入死锁状态，分配失败!"<<endl;
				for (int i=0;i<S;i++)
				{
					Available[i]=Available[i]+Request[i];
					Allocation[flag][i]=Allocation[flag][i]-Request[i];
					Need[flag][i]=Need[flag][i]+Request[i];
				}
			}
			//o
		}
	}
}

int main()
{
	int i,j,p,s,number;
	char tempstring;
    cout<<endl;
    cout<<"输入资源种类："<<endl;
	cin>>s;
	S=s;
	cout<<"输入资源的名称和数量："<<endl;
	for(i=0;i<s;i++)
	{
		cin>>tempstring>>number;
		name[i]=tempstring;
		Available[i]=number;
	}
	cout<<"输入进程的数量："<<endl;
	cin>>p;
	P=p;
	cout<<"输入各进程资源最大需求量："<<endl;
	for (i=0;i<p;i++)
	{
		for (j=0;j<s;j++)
		{
			cin>>Max[i][j];
		}
	}
	cout<<"输入各进程资源已分配量："<<endl;
	for (i=0;i<p;i++)
	{
		for (j=0;j<s;j++)
		{
			cin>>Allocation[i][j];
			Available[j]=Available[j]-Allocation[i][j];
		}
	}
	for (i=0;i<p;i++)
	{
		for (j=0;j<s;j++)
		{
			Need[i][j]=Max[i][j]-Allocation[i][j];
		}
	}
	Share();
	Showdata();
	Judgesafe();	
	return 0;
}

运行截图：