【操作系统】小型银行家算法实现

一.银行家算法简单介绍： 

    银行家算法是一种避免死锁的算法。在避免死锁方法中同意进程动态地申请资源，但系统在进行资源分配之前，应先j检查并计算此次分配资源的安全性，若分配不恰当会导致导致系统进入不安全状态，则等待.假设处于安全状态则分配。

    输入一些资源量，最大须要的资源量，已开辟的资源量，而且已知在进程里面可分配资源的数量。当某一个进程请求时，推断子请求是否合理。

我是用结构体存放数据的，我认为这样比較让自己easy接受。

二.程序模块

      1.初始化模块。

      2.试探分配模块。

      3.资源回收模块。

      4.安全性检查模块。

      5.资源请求分配模块。

      6.主函数，自己输入数据測试。

三.程序流程图

所有流程图：

 

（2）安全性检查流程图

（3）资源分配流程图      

                                                                                                                          開始

    代码：

#include <stdio.h>
#include <string.h>


#define false 0
#define All_Reource 50
#define Vallue     10


typedef struct
{
	int arr[Vallue];
	
}Resource;



int safe[All_Reource] = { 0 };


Resource ptr;
Resource Resource_Max[All_Reource] = { 0 };//最大需求矩阵
Resource Resource_Allocation[All_Reource] = { 0 };//已分配资源数矩阵
Resource Resource_Need[All_Reource] = { 0 };//需求矩阵


//可用资源向量
Resource Available;
Resource Work;

//int safe[All_Reource] = { 0 };
void Init(int Numz)
{
	int i;
	for (i = 0; i < Numz; i++)
	{   printf("请输入可用资源向量Ava:
");
		scanf("%d", &Available.arr[i]);
	}
}

void Resource_Max_Init(int Num, int Numz)

{
	for (int i = 0; i<Num; i++)
	{
		//printf("please input the P%d source
", i);
		printf("please input  the number of P%d max source 
 ", i);
		for (int j = 0; j < Numz; j++)
		{
			printf("请输入 P%d 的%d类资源:
", i, j);
			scanf("%d", &Resource_Max[i].arr[j]);
		}

	}
}

void Resource_Allocation_Init(int Num,int Numz)

{
	for (int i = 0; i < Num; i++)
	{
		printf("please input the P%d source
", i);
		for (int j = 0; j < Numz; j++)
		{
			printf("请输入 P%d 的%d类分配的资源:
", i, j);
			scanf("%d", &Resource_Allocation[i].arr[j]);
		}
	}
}
//void Resource_Need_Init(int Num,int Numz)
//
//{
//	for (int i = 0; i<Num; i++)
//	{
//		printf("please input the P%d's source
", i);
//		for (int j = 0; j < Numz; j++)
//		{
//			printf("请输入 P%d 的%d类须要的资源:
", i, j);
//			scanf("%d", &Resource_Need[i].arr[j]);
//		}
//	}
//}

void  Resource_Need_Init(int Num,int Numz)
{
	for (int i = 0; i < Num;i++)
	{
		for (int j = 0; j < Numz;j++)
		{
			Resource_Need[i].arr[j] = Resource_Max[i].arr[j] - Resource_Allocation[i].arr[j];
		}

	}
}


//试探分配
void ProbeAlloc(int process, Resource *res,int Numz)
{
	for (int i = 0; i < Numz; i++)
	{
		Available.arr[i] -= res->arr[i];
		Resource_Allocation[process].arr[i] += res->arr[i];
		Resource_Need[process].arr[i] -= res->arr[i];
	}
}

//若试探分配后进入不安全状态，将以试分配的的资源回收
void RollBack(int process, Resource *res,int Numz)
{
	for (int i = 0; i < Numz; i++)
	{
		Available.arr[i] += res->arr[i];
		Resource_Allocation[process].arr[i] -= res->arr[i];
		Resource_Need[process].arr[i] += res->arr[i];
	}
}

//安全性检查
bool SafeCheck(int Num,int Numz)
{
	int num = 0;
	int Finish[All_Reource];
	for (; num < Num; num++)
	{
		Finish[num] = { false };
	}
	int		i;
	int		j = 0;
	Work = Available;
	for (i = 0; i < Num; i++)
	{
		//是否已检查过
		if (Finish[i] == false)
		{
			int n = 0;
			//是否有足够的资源分配给该进程
			for (n=0; n < Numz;)
			{
				if (Resource_Need[i].arr[n] <= Work.arr[n])
				{
					n++;
				}
				else
				{
					break;
				}
			}
			if (n==Numz)
			{
             for (int nb = 0; nb < Numz; nb++)
				  {
					Work.arr[nb] += Resource_Allocation[i].arr[nb];	
				  }
				Finish[i] = true;
				safe[j++] = i;
				i = -1;
			}
			

		}
	}

	//假设全部进程的Finish向量都为true则处于安全状态，否则为不安全状态
	for (i = 0; i < Num; i++)
	{
		if (Finish[i] == false)
		{
			return false;
		}
	}
	return true;
}

//资源分配请求
bool request(int process, Resource *res, int Num,int Numz)
{
	int j;
	int i;
	for (i = 0; i < Numz;)
	{
		if (res->arr[i] <= Resource_Need[process].arr[i])//请求量是否小于需求量
		{
			i++;
		}
		else
		{
			printf("请求量大于需求量
");
			return false;
		}
	}

	for (j = 0; j < Numz;)
	{
		if (res->arr[j] <= Available.arr[j])//请求量是否小于系统的可用资源量
		{
			j++;
		}
		else
		{
			printf("请求量大于需可用量
");
			return false;
		}
	}

	//试探分配
	ProbeAlloc(process, res,Numz);

	//假设安全检查成立，则请求成功，否则将分配失败并返回失败
	if (SafeCheck(Num, Numz))
	{
		return true;
	}
	else
	{
		printf("安全性检查失败。系统将进入不安全状态
");
		RollBack(process, res,Numz);
		return false;
	}
	
			
}

void PrintfTable(int Numz)
{
	int i;
	printf("Ava :");
	for (i = 0; i < Numz; i++)
	{
		printf("%d  ",Available.arr[i]);
	}
	printf("
");

}

int main()

{
	int y;
	int d;
	int	ch;
	
	int num = 0;
	int numz = 0;
	int i = 0;
	printf("请输入进程总数: ");
	scanf("%d", &num);
	printf("请输入资源种类: ");
	scanf("%d", &numz);
	for (i = 0; i < numz; i++)
	{
		ptr.arr[i] = i;
	}
	Init(numz);
	Resource_Max_Init(num, numz);
	Resource_Allocation_Init(num, numz);
	Resource_Need_Init(num, numz);
	printf("先检查初始状态是否安全
");
    if (SafeCheck(num, numz))
	{
		//printf("系统处于安全状态
");
		printf("输出安全序列：
");
		for (d = 0; d < num; d++)
		{
			printf("p%d", safe[d]);
		}
		printf("
");
	}
	else
	{
		printf("系统处于不安全状态,程序将退出...
");
		getchar();
		return -1;
	}
	do
	{
		int		process;
		Resource	res;
		PrintfTable(numz);
		printf("请输入须要请求的进程数：");
		scanf("%d", &process);
		for (y = 0; y < numz; y++)
		{
			printf("请输入进程数%d分配资源数量%d: ", process, y);
			scanf("%d", &res.arr[y]);
		}

		if (request(process, &res, num, numz))
		{
			int a;
			printf("分配成功。
");
			printf("输出安全序列：
");
			for (a = 0; a < num; a++)
			{
				printf("p%d", safe[a]);
				printf("
");
			}
			//PrintfTable(numz);
			int n1 = 0;
			for (int i = 0; i < numz;i++)
			{
				if (Resource_Need[process].arr[i]==0)
				{
					n1++;
				}
				else
				{
					break;
				}
			}
			if (n1 == numz)
			{
				for (int i = 0; i < numz;i++)
				{
					Available.arr[i] += Resource_Allocation[process].arr[i];
				}
			}
			
			PrintfTable(numz);
		}
		else
		{
			printf("分配失败。
");
		}
		printf("是否继续分配？(Y/N):");
		fflush(stdin);				
		ch = getchar();
	} while (ch == 'Y' || ch == 'y');
	
	return 0;
}

：

     

（流程图太大了，不好截图。所以仅仅能分开截图）。