银行家算法

1.设计目的与要求

1.1设计目的

        了解银行家算法中使用的数据结构和求安全序列算法，并进一步加深对避免死锁算法及其实现过程的理解。

1.2设计要求

        通过编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用适当的算法，有效地防止和避免死锁的发生。

2.设计思想及系统平台

2.1设计思想

        基本思想分为两个模块，一是银行家算法模块，二是安全性检查模块。当有进程申请资源时，先检查系统是否能够满足进程的请求，此时程序进入安全性检查模块，如果安全就分配，不安全就拒绝申请。

        本算法的数据结构：

        1）可利用资源向量Available。这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目。

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

        3）分配矩阵Allocation。这也是一个n×m的矩阵，定义了系统中每一类资源当前已分配给每一进程的资源数。

        4）需求矩阵Need。这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。

        由数学知识可知，Need[i,j]=Max[i,j]-Allocation[i,j]。

2.2系统平台及使用语言

        CodeBlocks，C++

3.详细算法描述

1）初始化函数Init()

        用户输入数据，初始化可利用资源向量矩阵AVAILABLE、最大需求矩阵MAX、分配矩阵ALLOCATION、 需求矩阵NEED。

 

2）银行家算法Order()

        当进程Pi发出资源请求后，系统按以下步骤进行检查：

        ①如果Request[i,j]<=Need[i,j]，便转向步骤②；否则出错，因为它请求的资源数已超过它的需求最大值。

        ②如果Request[i,j]<=Available[j]，便转向步骤③；否则，表示当前资源不足，Pi须等待

        ③系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：Available[j]= Available[j]-Request i[j]、Allocation[i,j]= Allocation[i,j]+Request[i,j]、Need[i,j]= Need[i,j]-Request[i,j]

        ④系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程Pi；否则，恢复原来的资源分配状态，让进程Pi等待。

 

3）安全性检查算法Safecheck()

        ①设置两个向量：工作向量Work，表示系统可提供给进程继续运行所需的各类资源数目，初始化Work=Available；Finish，表示系统是否有足够的资源分配给进程，初始化Finish[i]=false；当有足够资源分配给进程时，再令Finish[i]=true。

        ②从进程集合中找到一个能满足下述条件的进程：Finish[i]=false；Need[i,j]≤Work[j]；若找到，执行步骤③，否则，执行步骤④。

        ③假设进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：Work[j]= Work[j]+Allocation[i,j]；Finish[i]=true；go to step ②

        ④如果所有进程的Finish[i]=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

4.源代码

#include <iostream>
#include <vector>
using namespace std;
#define MAX 20
int n_process;//表示进程的个数
int n_resource;//表示资源的个数
int Resource[MAX];//表示资源的总数
int Max[MAX][MAX];//表示进程对每类资源的最大需求量
int Allocation[MAX][MAX];//表示系统给进程已分配每类资源的数目
int Need[MAX][MAX];//表示进程还需各类资源数目
int Available[MAX];//表示系统当前剩下的资源
int Work[MAX];//表示安全性检查的中间变量
bool Finish[MAX];//表示资源是否被安全性检查过
vector<int> Safeorder;//表示安全序列
void Menu()
{
	cout << "------------银行家算法----------------" << endl;
	cout << "*          1.初始化数据              *" << endl;
	cout << "*          2.申请资源                *" << endl;
	cout << "*          3.显示资源分配情况        *" << endl;
	cout << "*          4.退出                    *" << endl;
	cout << "--------------------------------------" << endl;
	cout << "请选择：";
}
//检查初始化数值是否合理
void checkInit()
{
	if (n_resource)
	for (int i = 0; i < n_process; i++)
	{
		for (int j = 0; j < n_resource; j++)
		{
			if (Max[i][j] < 0)
            {
                cout << "Max[" << i << "][" << j << "]输入值小于0！" << endl;
            }
			if (Allocation[i][j] < 0)
			{
			    cout << "Allocation[" << i << "][" << j << "]输入值小于0！" << endl;
			}
			if (Allocation[i][j]>Max[i][j])
            {
                cout << "Allocation[" << i << "][" << j << "]的值大于Max[" << i << "][" << j << "]输入值" << endl;
            }
		}
	}
	for (int i = 0; i < n_resource; i++)
	{
		if (Available[i]<0)
        {
            cout << "Available[" << i << "]的值小于0！" << endl;
        }
	}
	cout << "检查完毕，输入无误！" << endl;
}
//初始化进程和资源
int Init()
{
	if (n_resource != 0 && n_process != 0)
	{
		cout << "已经初始化过了！" << endl;
		return 1;
	}
	cout << "请分别输入资源个数和进程个数，中间用空格隔开：" << endl;
	cin >> n_resource >> n_process;
	cout << "请输入各个资源的总拥有量：" << endl;
	for (int i = 0; i < n_resource; i++)
    {
        cin >> Resource[i];
    }
	for (int i = 0; i < n_process; i++)
	{
		cout << "P" << i << "对各个资源的最大需求量：" << endl;
		for (int j = 0; j < n_resource; j++)
        {
            cin >> Max[i][j];
        }
		cout << "P" << i << "各个资源已分配量：" << endl;
		for (int j = 0; j < n_resource; j++)
        {
            cin >> Allocation[i][j];
        }
		for (int j = 0; j < n_resource; j++)
        {
            Need[i][j] = Max[i][j] - Allocation[i][j];
        }
	}
	for (int i = 0; i < n_resource; i++)
	{
		int sum[MAX] = { 0 };
		for (int j = 0; j < n_process; j++)
		{
		    switch(i)
		    {
                case 0:
                case 1:
                case 2:
                    sum[i] += Allocation[j][i];
                    break;
		    }
		}
		Available[i] = Resource[i] - sum[i];
	}
	checkInit();
	return 1;
}
//安全性检查
bool Safecheck()
{
    //清空原来的安全序列
	Safeorder.clear();
    //Work初始化为Available
	for (int i = 0; i < n_resource; i++)
    {
        Work[i] = Available[i];
    }
    //还没开始检查，设置标志为false
	for (int i = 0; i < n_process; i++)
    {
        Finish[i] = false;
    }
	//开始安全性检查
	int count = 0;
	for (int k = 0; k < n_process; k++)
	{
		for (int i = 0; i < n_process; i++)
		{
			if (Finish[i] == false)
			{
				count = 0;
				for (int j = 0; j < n_resource; j++)
				{
					if (Need[i][j] <= Work[j])
						count++;
				}
				//如果进程所需的各个资源数都没有超过系统现有的对应资源数
				if (count == n_resource)
				{
					for (int j = 0; j < n_resource; j++)
					{
					    //将Work赋值为 第i个进程各个已分配资源数＋系统现有的对应资源数
						Work[j] = Work[j] + Allocation[i][j];
					}
					Finish[i] = true;
					Safeorder.push_back(i);//加入到安全序列
				}
			}
		}
	}
	count = 0;
	//安全的进程数
	for (int i = 0; i < n_process; i++)
	{
		if (Finish[i] == true)
			count++;
	}
	if (count == n_process)
		return true;
	else
		return false;
}
//请求进程
int Order()
{
	int n = -1; //请求资源的进程号
	int *Request = new int[n_resource];//表示请求的各个资源数量
	cout << "请输入你要请求的进程号：";
	cin >> n;
	cout << "请输入你要请求各个资源的数量，中间用空格隔开：" << endl;
	for (int i = 0; i< n_resource; i++)
    {
        cin >> Request[i];
    }
	//开始判断
    //请求量大于该进程的最大需求量，出错
	for (int i = 0; i < n_resource; i++)
	{
		if (Need[n][i] < Request[i])
		{
			cout << "输入错误，请求量不能比该进程的最大需求量还大！" << endl;
			return 1;
		}
	}
	//请求量大于当前空闲资源量，出错
	for (int i = 0; i < n_resource; i++)
	{
		if (Available[i] < Request[i])
		{
			cout << "拒绝，当前空闲资源不够！" << endl;
			return 1;
		}
	}
	//请求量合理，试图分配资源给请求进程，并做安全性检查
	for (int i = 0; i < n_resource; i++)
	{
		Available[i] -= Request[i];
		Allocation[n][i] += Request[i];
		Need[n][i] -= Request[i];
	}
	//安全性检查
	bool Is_safe=Safecheck();
	if (Is_safe == true)
	{
		cout << "系统已经分配资源给P" << n << "进程了！" << endl;
		cout << "其中一个安全序列为：" << endl;
		for (int i = 0; i < Safeorder.size(); i++)
        {
            cout << "P" << Safeorder.at(i) << "->";
        }
		cout << "End" << endl ;
	}
	//不安全，恢复试分配之前的现场
	else
	{
		cout << "不能分配资源，否则系统会处于不安全状态！" << endl;
		for (int i = 0; i < n_resource; i++)
		{
			Available[i] += Request[i];
			Allocation[n][i] -= Request[i];
			Need[n][i] += Request[i];
		}
	}
	return 1;
}
//显示资源分配情况
void Display()
{
	cout << endl;
	cout << "进程 \t Max \t Allocation\tNeed\tAvailable" << endl;
	for (int i = 0; i < n_process; i++)
	{
		cout << " P" << i << " \t";
		for (int j = 0; j < n_resource; j++)
		{
			cout << Max[i][j] << " ";
		}
		cout << "\t   ";
		for (int j = 0; j < n_resource; j++)
		{
			cout << Allocation[i][j] << " ";
		}
		cout << "\t";
		for (int j = 0; j < n_resource; j++)
		{
			cout << Need[i][j] << " ";
		}
		cout << "\t  ";
		for (int j = 0; i==0&&j < n_resource; j++)
		{
			cout << Available[j] << " ";
		}
		cout << endl;
	}
	cout << endl;
}

int main()
{
	int choose = 0;
	while (1)
	{
		Menu();
		cin >> choose;
		switch (choose)
		{
            case 1:
                Init();
                break;
            case 2:
                Order();
                break;
            case 3:
                Display();
                break;
            case 4:
                cout << "系统已退出！";
                return 1;
            default:
                cout << "输错了，重输" << endl;
                break;
		}
	}
}

 实验报告：https://download.csdn.net/download/sjhdxpz/88212618