银行家算法(DAY 48)

1：输出随机数版本：

实验8——银行家算法

一．算法说明
先对用户提出的请求进行合法性检查，再进行预分配，利用安全性检查算法进行安全性检查。
1.进程一开始向系统提出最大资源需求量；
2.进程每次提出新的资源请求都统计是否超出它事先提出的最大需求量；
3.若正常，则判断该进程所需剩余资源量(包括本次申请)是否超出系统所掌握的剩余资源量，若不超出，则分配，否则等待。
二. 实验要求
1.修改程序的输出，提高其结果可读性；
2.在已有算法的基础上，试输出所有可能的安全序列；
3.修改MAX[M][N]的值为随机生成时，查看对安全序列的影响。

2：代码实现

#include<string.h>
#include<stdlib.h>
#include<stdio.h>/*用到了getch()*/
#include<math.h>
#include<time.h>

# define M 5/*进程数*/
# define N 3/*资源种类*/

# define FALSE 0
# define TRUE 1
 
/*M个进程对N类资源最大资源需求量*/
//int MAX[M][N] = { {7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3} };
int MAX[M][N];
/*系统可用资源数*/
int AVAILABLE[N] = { 10,5,7 };
/*M个进程已分配到的N类数量*/
int ALLOCATION[M][N] = { {0,0,0},{0,0,0},{0,0,0},{0,0,0},{0,0,0} };
/*M个进程已经得到N类资源的资源量*/
int NEED[M][N];// = { {7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3} };
/*M个进程还需要N类资源的资源量*/
int Request[N] = { 0,0,0 };
void main()
{
	srand(time(0));
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < N; j++)
		{
			int a;
			a = rand() % 5;
			MAX[i][j] = a;
			NEED[i][j] = a;
		}
	}
	int i = 0, j = 0;
	char flag;
	void showdata();
	void changdata(int);
	void rstordata(int);
	int chkerr();
	showdata();
enter:
	{
		printf("请输入需申请资源的进程号（从0到");
		printf("%d", M - 1);
		printf("）:");
		scanf("%d", &i);
	}
	if (i < 0 || i >= M)
	{
		printf("输入的进程号不存在，重新输入!\n");
		goto enter;
	}
err:
	{
		printf("请输入进程");
		printf("%d", i);
		printf("申请的资源数\n");
		printf("类别:ABC\n");
		printf("");
		for (j = 0; j < N; j++)
		{
			scanf("%d", &Request[j]);
			if (Request[j] > NEED[i][j])
			{
				printf("%d号进程", i);
				printf("申请的资源数>进程");
				printf("%d", i);
				printf("还需要%d类资源的资源量!申请不合理，出错!请重新选择!\n", j);
				goto err;
			}
			else
			{
				if (Request[j] > AVAILABLE[j])
				{
					printf("进程");
					printf("%d", i);
					printf("申请的资源数大于系统可用");
					printf("%d", j);
					printf("类资源的资源量!申请不合理，出错!请重新选择!\n");
					goto err;
				}
			}
		}
	}
	changdata(i);
	if (chkerr())
	{
		rstordata(i);
		showdata();
	}
	else
		showdata();
	printf("\n");
	printf("按'y'或'Y'键继续,否则退出\n");
	flag = getchar();
	if (flag == 'y' || flag == 'Y')
	{
		goto enter;
	}
	else
	{
		exit(0);
	}
}
/*显示数组*/
void showdata()
{
	int i, j;
	printf("系统可用资源向量:\n");
	printf("***Available***\n");
	printf("资源类别:ABC\n");
	printf("资源数目:");
	for (j = 0; j < N; j++)
	{
		printf("%d", AVAILABLE[j]);
	}
	printf("\n");
	printf("\n");
	printf("各进程还需要的资源量:\n");
	printf("******Need******\n");
	printf("资源类别:ABC\n");
	for (i = 0; i < M; i++)
	{
		printf("");
		printf("%d", i);
		printf("号进程:");
		for (j = 0; j < N; j++)
		{
			printf("%d", NEED[i][j]);
		}
		printf("\n");
	}
	printf("\n");
	printf("各进程已经得到的资源量:\n");
	printf("***Allocation***\n");
	printf("资源类别:ABC\n");
	for (i = 0; i < M; i++)
	{
		printf("");
		printf("%d", i);
		printf("号进程:");
		/*printf(":\n");*/
		for (j = 0; j < N; j++)
		{
			printf("%d", ALLOCATION[i][j]);
		}
		printf("\n");
	}
	printf("\n");
}
/*系统对进程请求响应，资源向量改变*/
void changdata(int k)
{
	int j;
	for (j = 0; j < N; j++)
	{
		AVAILABLE[j] = AVAILABLE[j] - Request[j];
		ALLOCATION[k][j] = ALLOCATION[k][j] + Request[j];
		NEED[k][j] = NEED[k][j] - Request[j];
	}
}
/*资源向量改变*/
void rstordata(int k)
{
	int j;
	for (j = 0; j < N; j++)
	{
		AVAILABLE[j] = AVAILABLE[j] + Request[j];
		ALLOCATION[k][j] = ALLOCATION[k][j] - Request[j];
		NEED[k][j] = NEED[k][j] + Request[j];
	}
}
/*安全性检查函数*/
int chkerr()//在假定分配资源的情况下检查系统的安全性
{
	int WORK[N], FINISH[M], temp[M];//temp[]用来记录进程安全执行的顺序
	int i, j, m, k = 0, count;
	for (i = 0; i < M; i++)
		FINISH[i] = FALSE;
	for (j = 0; j < N; j++)
		WORK[j] = AVAILABLE[j];//把可利用资源数赋给WORK[]
	for (i = 0; i < M; i++)
	{
		count = 0;
		for (j = 0; j < N; j++)
			if (FINISH[i] == FALSE && NEED[i][j] <= WORK[j])
				count++;
		if (count == N)//当进程各类资源都满足NEED<=WORK时
		{
			for (m = 0; m < N; m++)
				WORK[m] = WORK[m] + ALLOCATION[i][m];
			FINISH[i] = TRUE;
			temp[k] = i;//记录下满足条件的进程
			k++;
			i = -1;
		}
	}
	for (i = 0; i < M; i++)
		if (FINISH[i] == FALSE)
		{
			printf("系统不安全!!!本次资源申请不成功!!!\n");
			return 1;
		}
	printf("\n");
	printf("经安全性检查，系统安全，本次分配成功。\n");
	printf("\n");
	printf("本次安全序列：");
	for (i = 0; i < M; i++)//打印安全系统的进程调用顺序
	{
		printf("进程");
		printf("%d", temp[i]);
		if (i < M - 1)
			printf("->");
	}
	printf("\n");
	return 0;
}

3：银行家算法真正实现

#include<stdio.h>
#define resourceNum 3
#define processNum  5

//系统可用（剩余）资源
int available[resourceNum]={3,3,2};
//进程的最大需求
int maxRequest[processNum][resourceNum]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
//进程已经占有（分配）资源
int allocation[processNum][resourceNum]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
//进程还需要资源
int need[processNum][resourceNum]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};
//是否安全
bool Finish[processNum];
//安全序列号
int safeSeries[processNum]={0,0,0,0,0};
//进程请求资源量
int request[resourceNum];
//资源数量计数
int num;

//打印输出系统信息
void showInfo()
{
	printf("\n------------------------------------------------------------------------------------\n");  
	printf("当前系统各类资源剩余：");
    for(int j = 0; j < resourceNum; j++)
	{
        printf("%d ",available[j]);
    }
    printf("\n\n当前系统资源情况：\n");
    printf(" PID\t Max\t\tAllocation\t Need\n");
    for(int i = 0; i < processNum; i++)
	{
        printf(" P%d\t",i);
        for(int j = 0; j < resourceNum; j++)
		{
            printf("%2d",maxRequest[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++)
		{
            printf("%2d",allocation[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++)
		{
            printf("%2d",need[i][j]);
        }
        printf("\n");
    }
}

//打印安全检查信息
void SafeInfo(int *work, int i)
{
    int j;
    printf(" P%d\t",i);
    for(j = 0; j < resourceNum; j++)
	{
        printf("%2d",work[j]);
    }   
    printf("\t\t");
    for(j = 0; j < resourceNum; j++)
	{
        printf("%2d",allocation[i][j]);
    }
	printf("\t\t");
    for(j = 0; j < resourceNum; j++)
	{
        printf("%2d",need[i][j]);
    }
    printf("\t\t");
    for(j = 0; j < resourceNum; j++)
	{
        printf("%2d",allocation[i][j]+work[j]);
    }
    printf("\n");
}

//判断一个进程的资源是否全为零
bool isAllZero(int kang)
{
	num = 0;
	for(int i = 0; i < resourceNum; i++ )
	{
		if(need[kang][i] == 0)
		{
			num ++;
		}
	}
	if(num == resourceNum)
	{
		return true;
	}
	else
	{
		return false;
	}   
}

//安全检查
bool isSafe()
{
	//int resourceNumFinish = 0;
	int safeIndex = 0;
	int allFinish = 0;
    int work[resourceNum] = {0};
	int r = 0;
	int temp = 0;
	int pNum = 0;
	//预分配为了保护available[]
    for(int i = 0; i < resourceNum; i++)
	{		
        work[i] = available[i];	
    }
	//把未完成进程置为false
    for(i = 0; i < processNum; i++)
	{
		bool result = isAllZero(i);
		if(result == true)
		{
			Finish[i] = true;
			allFinish++;
		}
		else
		{
			Finish[i] = false;
		}

    }
	//预分配开始
    while(allFinish != processNum)
	{
		num = 0;	
        for(i = 0; i < resourceNum; i++)
		{
			if(need[r][i] <= work[i] && Finish[r] == false)
			{
				num ++;
			}			
		}
		if(num == resourceNum)
		{		
			for(i = 0; i < resourceNum; i++ )
			{
				work[i] = work[i] + allocation[r][i];
			}
			allFinish ++;
			SafeInfo(work,r);
			safeSeries[safeIndex] = r;
			safeIndex ++;
			Finish[r] = true;
		}
		r ++;//该式必须在此处	
		if(r >= processNum)
		{
			r = r % processNum;
			if(temp == allFinish)
			{
				break;	
			}
			temp = allFinish;
		}		
		pNum = allFinish;
    }	
	//判断系统是否安全
	for(i = 0; i < processNum; i++)
	{
		if(Finish[i] == false)
		{
			printf("\n当前系统不安全！\n\n");
			return false;	
		}
	}
	//打印安全序列
	printf("\n当前系统安全！\n\n安全序列为：");
	for(i = 0; i < processNum; i++)
	{	
		bool result = isAllZero(i);
		if(result == true)
		{		
			pNum --;
		}	
    }
	for(i = 0; i < pNum; i++)
	{
		printf("%d ",safeSeries[i]);
	}
    return true;
}

//主函数
void main()
{
    int curProcess = 0;
	int a = -1;
       showInfo(); 
	printf("\n系统安全情况分析\n");
	printf(" PID\t Work\t\tAllocation\t Need\t\tWork+Allocation\n");
	bool isStart = isSafe();
	//用户输入或者预设系统资源分配合理才能继续进行进程分配工作
    while(isStart)
	{
		//限制用户输入，以防用户输入大于进程数量的数字，以及输入其他字符（乱输是不允许的）
      	do
		{ 
			if(curProcess >= processNum || a == 0)
			{
				printf("\n请不要输入超出进程数量的值或者其他字符：\n");
				while(getchar() != '\n'){};//清空缓冲区	
				a = -1;
			}
			printf("\n------------------------------------------------------------------------------------\n");
			printf("\n输入要分配的进程：");
			a = scanf("%d",&curProcess);
			printf("\n");

		}while(curProcess >= processNum || a == 0);
		
		//限制用户输入，此处只接受数字，以防用户输入其他字符（乱输是不允许的）
		for(int i = 0; i < resourceNum; i++)
		{
			do
			{
				if(a == 0)
				{
					printf("\n请不要输入除数字以外的其他字符，请重新输入：\n");
					while(getchar() != '\n'){};//清空缓冲区	
					a = -1;
				}
				printf("请输入要分配给进程 P%d 的第 %d 类资源：",curProcess,i+1);
				a = scanf("%d", &request[i]);
			}while( a == 0);
		}

		//判断用户输入的分配是否合理，如果合理，开始进行预分配
		num  = 0;
        for(i = 0; i < resourceNum; i++)
		{
            if(request[i] <= need[curProcess][i] && request[i] <= available[i])
			{
				num ++;
			}
            else
			{
				printf("\n发生错误！可能原因如下：\n(1)您请求分配的资源可能大于该进程的某些资源的最大需要！\n(2)系统所剩的资源已经不足了！\n");
				break;
			}
        }
        if(num == resourceNum)
		{	
			num = 0;	
            for(int j = 0; j < resourceNum; j++)
			{
				//分配资源
                available[j] = available[j] - request[j];
                allocation[curProcess][j] = allocation[curProcess][j] + request[j];
                need[curProcess][j] = need[curProcess][j] - request[j];
				//记录分配以后，是否该进程需要值为0了
				if(need[curProcess][j] == 0)
				{
					num ++;
				}
            }
			//如果分配以后出现该进程对所有资源的需求为0了，即刻释放该进程占用资源（视为完成）
			if(num == resourceNum)
			{
				//释放已完成资源
				for(int i = 0; i < resourceNum; i++ )
				{
					available[i] = available[i] + allocation[curProcess][i];
				}
				printf("\n\n本次分配进程 P%d 完成,该进程占用资源全部释放完毕！\n",curProcess);
			}
			else
			{
				//资源分配可以不用一次性满足进程需求
				printf("\n\n本次分配进程 P%d 未完成！\n",curProcess);
			}

			showInfo();
           	printf("\n系统安全情况分析\n");
			printf(" PID\t Work\t\tAllocation\t Need\t\tWork+Allocation\n");

			//预分配完成以后，判断该系统是否安全，若安全，则可继续进行分配，若不安全，将已经分配的资源换回来
            if(!isSafe())
			{ 	        
				for(int j = 0; j < resourceNum; j++)
				{
					available[j] = available[j] + request[j];
					allocation[curProcess][j] = allocation[curProcess][j] - request[j];
					need[curProcess][j] = need[curProcess][j] +request[j];
				}
				printf("资源不足，等待中...\n\n分配失败！\n");				
            }
        }
    }
}