精华内容
下载资源
问答
  • 模拟银行家算法,用银行家算法实现资源分配 1.问题及分析 已知进程{P0,P1,P2,P3,P4},有三类系统资源A、B、C的数量分别为10、5、7,在T0时刻的资源分配情况如下图所示: (1)判断T0时刻的安全状态,安全则输出安全...

    模拟银行家算法,用银行家算法实现资源分配

    1.问题及分析

    已知进程{P0,P1,P2,P3,P4},有三类系统资源A、B、C的数量分别为10、5、7,在T0时刻的资源分配情况如下图所示:
    (1)判断T0时刻的安全状态,安全则输出安全序列,否则输出“不是安全状态!”
    在这里插入图片描述
    (2)若此时进程P1请求资源,发出请求向量Request1(1,1,2),编写程序用银行家算法判断系统能否将资源分配给它;
    (3,3,2)-(1,1,2)=(2,2,0)
    在这里插入图片描述
    (3)若接着进程P0提出请求Request(0,1,1),用银行家算法程序验证系统能否分配资源。
    (3,3,2)-(0,1,1)=(3,2,1)
    在这里插入图片描述
    2.实验结果

    (1)在这里插入图片描述
    (2)在这里插入图片描述
    (3)在这里插入图片描述

    展开全文
  • 银行家算法资源分配问题(例子!!!)

    万次阅读 多人点赞 2021-04-07 14:49:10
    银行家算法中,若出现表2-4所示的资源分配情况,试问: 该状态是否安全? 如果进程P2提出请求Request2(1,2,2,2)后,系统能否将资源分配给它。 表2-4 资源分配表 Allocation Need ...

    在银行家算法中,若出现表2-4所示的资源分配情况,试问:

    1. 该状态是否安全?
    2. 如果进程P2提出请求Request2(1,2,2,2)后,系统能否将资源分配给它。

     

    表2-4  资源分配表

     

    Allocation

    Need

    Available

    A   B   C    D

    A   B   C    D

    A   B   C    D

    P0

    0   0    3    2

    0   0    1    2

    1    6   2     2

    P1

    1   0    0    0

    1   7    5    0

    P2

    1   3    5    4

    2   3    5    6

    P3

    0   3    3    2

    0   6    5    2

    P4

    0   0    1    4

    0   6    5    6

    解答:

    (1)利用银行家算法对此时刻的资源分配情况进行分析,可得表2-5所示的安全性分析情况。

    表2-5 安全性检查表

     

    Work

    Need

    Allocation

    Work+Allocation

    Finish

    A  B  C  D

    A  B C  D

    A  B  C D

    A   B    C    D

    P0

    1  6  2  2

    0  0  1  2

    0  0  3  2

    1   6    5    4

    true

     

    true

     

    true

     

    true

     

    true

    P3

    1  6  5  4

    0  6  5  2

    0  3  3  2

    1   9    8    6

    P4

    1  9  8  6

    1  7  5  0

    0  0  1  4

    1   9    9   10

    P1

    1  9  9  10

    0  6  5  6

    1  0  0  0

    2   9    9   10

    P2

    2  9  9  10

    2  3  5  6

    1  3  5  4

    3  12  14  14

    从以上情况分析可以看出,此时存在一个安全序列{p0,p3,p4,p1,p2},故该状态是安全的。

     

    (2)P2提出请求Request2(1,2,2,2)。按银行家算法进行检查:

    Request2(1,2,2,2)<=need(2,3,5,6)

    Request2(1,2,2,2)<=available(1,6,2,2)

    试分配并修改相应数据结构,资源分配情况如表2-6所示。

    表2-6  P2申请资源后的资源分配表

     

    Allocation

    Need

    Available

    A   B   C    D

    A   B   C    D

    A   B   C    D

    P0

    0   0    3    2

    0   0    1    2

    0    4   0     0

    P1

    1   0    0    0

    1   7    5    0

    P2

    1   3    5    4

    1   1    3    4

    P3

    0   3    3    2

    0   6    5    2

    P4

    0   0    1    4

    0   6    5    6

    再利用安全性检查算法检查系统是否安全,可用资源available(0,4,0,0)已不能满足任何进程的需要,此时系统不能将资源分配给P2。

    展开全文
  • 1. 银行家算法(模拟设备分配和回收的算法)  用高级语言编写一个银行家的模拟算法。  设置恰当的数据结构,有效存储数据。   输出分配过程、分配结果以及其它相关的信息。  界面友好,提示清晰。
  • 银行家算法 资源分配

    2011-12-06 17:53:07
    银行家算法和随机分配算法实现资源分配 在实习中假定系统中任一资源在每一时刻只能则由一个进程使用,任何进程不能抢占它进程正在使用的资源,当进程得不到资源时必须等待。因此只要资源分配策略能保证进程不出现...
  • 操作系统-资源分配银行家算法

    千次阅读 2020-11-16 20:43:09
    资源分配算----银行家算法 一、 实验目的 模拟实现银行家算法,用银行家算法实现资源分配和安全性检查。通过本次实验,使学生加深对死锁概念的理解和掌握,并培养学生对操作系统课程的兴趣与高级语言设计的能力。 ...

    资源分配----银行家算法

    一、 实验目的
    模拟实现银行家算法,用银行家算法实现资源分配和安全性检查。通过本次实验,使学生加深对死锁概念的理解和掌握,并培养学生对操作系统课程的兴趣与高级语言设计的能力。

    二、 实验内容 1、要求
    设计五个进程{P0···P4}共享三类资源{A,B,C}的系统,每一种资源数量为10,5,7。进程可动态的申请和释放资源,系统按各进程的申请动态地分配资源,在T0时刻的资源分配情况如下表:

    Name       Max        Allocation       Need       Available
    P0        7,5,3       0,1,0       7,4,3        3,3,2 
    P1        3,2,2       2,0,0       1,2,2 
    P2        9,0,2       3,0,2       6,0,0
    P3        2,2,2       2,1,1       0,1,1
    P4        4,3,3       0,0,2       4,3,1
    

    (1) 银行家算法的数据结构
    •Resource:一个长度为m向量,表示系统拥有的资源数目。
    •Available:一个长度为m向量,表示每类资源的可用数目。
    •Max:一个m×n矩阵,定义每个进程的最大资源需求数。
    •Allocation:一个m×n矩阵,定义当前分配给每个进程每类资源的数目。
    •Need:一个m×n矩阵,表示每个进程还需多少资源。

    (2) 实现银行家算法 设:Requesti是进程Pi的请求向量。
    当Pi发出资源请求后,系统按如下步骤进行检查:
    •如果Request[j] Need[i][j] 则go to 2,否则认为出错。
    •如果Request[j] < Available[i][j] 则go to 3,否则表示无足够资源, Pi等待。
    •系统进行试探分配,并求该相应数据结构数据
    Available:= Available- Requesti
    Allocationi:= Allocationi+ Requesti
    Needi:= Needi-Requesti
    •系统执行安全性算法:安全,把资源分配给Pi,否则, Pi等待。

    (3) 实现安全性算法
    •设Work 和 Finish是长度分别为m,n的向量
    初试值Work =Available ,Finishi = False(所有)
    •从进程集合中找到一个能满足下列条件的进程
    a. Finishi= False
    b. Needi Work 如找到go to 3 否则 go to 4
    •当进程Pi 获得资源后,顺利执行,直至完成,并释放分配给它的资源。
    Work = Work+ Allocationi
    Finishi:= True go to 2
    •如果所有进程的Finishi= True 则表示系统安全,否则为不安全。


    一、系统安全性检查模块

    方案一(不利用goto语句):

    //判断系统的安全性
    int judSystemSecurity()
    {
    	int i;
    	//更新系统可利用资源量
    	for (i = 0; i < resourseType; i++)
    	{
    		work[i] = available[i];
    	}
    
    	int allFinish = 0;
    	//把未完成进程置为0
    	for (i = 0; i < customerNumber; i++)
    	{
    		//判断当前进程是否已经完成并且可以回收资源
    
    		//如果已经全部完成
    		if (isFinish(i))
    		{
    			Finish[i] = 1;
    			allFinish++;
    		}
    		else
    		{
    			Finish[i] = 0;
    		}
    	}
    
    	int r = 0;//表示当前要判断是否要进行预分配的进程的下标
    	int safeIndex = 0;//安全序列的下标
    	int temp = 0;//临时变量
    	int pNum = 0;//保存临时变量的个数
    	//预分配开始,当进程没有全部完成时,一直执行循环
    	while (allFinish != customerNumber)
    	{
    		num = 0;
    		//判断是否可以预分配
    		for (i = 0; i < resourseType; i++)
    		{
    			if (need[r][i] <= work[i] && Finish[r] == 0)//判断是否可以预分配
    			{
    				num++;
    			}
    		}
    
    		//可以预分配
    		if (num == resourseType)
    		{
    			//输出进程Pr的各项信息
    			SafeInfo(work, r);
    			//回收资源
    			for (i = 0; i < resourseType; i++)
    			{
    				work[i] = work[i] + allocation[r][i];
    			}
    			//完成的进程数增加
    			allFinish++;
    			//保存安全序列
    			safeSeries[safeIndex] = r;
    			safeIndex++;
    			//当前进程安全
    			Finish[r] = 1;
    		}
    
    
    		r++;//该式必须在此处	
    		if (r >= customerNumber)
    		{
    			r = r % customerNumber;
    			if (temp == allFinish)//temp记录的是上一次循环分配后所有的进程完成数,将上一次进程数跟这次预分配后的进程数
    			{					  //进行对比,如果相等,则是不安全的情况,直接break;否则是安全的情况,继续执行
    				break;
    			}
    			temp = allFinish;//更新完成的进程数
    		}
    		pNum = allFinish;//保存安全序列的个数
    	}
    
    	//判断系统是否安全
    	for (i = 0; i < customerNumber; i++)
    	{
    		if (Finish[i] == 0)
    		{
    			return 0;
    		}
    	}
    
    	//打印安全序列
    	printf("\n安全序列为:");
    	for (i = 0; i < customerNumber; i++)
    	{
    		if (isFinish(i))
    		{
    			pNum--;
    		}
    	}
    	for (i = 0; i < pNum; i++)
    	{
    		printf("%d ", safeSeries[i]);
    	}
    	return 1;
    }
    

    方案二(利用goto语句):

    //方案二,利用goto语句
    int judSystemSecurity_1()
    {
    	int i, j;
    	for (i = 0; i < resourseType; i++)
    	{
    		work[i] = available[i];
    	}
    	for (i = 0; i < customerNumber; i++)
    	{
    		if (isFinish(i))
    		{
    			Finish[i] = 1;
    		}
    		else
    		{
    			Finish[i] = 0;
    		}
    	}
    
    	int safeIndex = 0;
    
    	NEXT:
    	for (i = 0; i < customerNumber; i++)
    	{
    		if (Finish[i] == 0)
    		{
    			for (j = 0; j < resourseType; j++)
    			{
    				if (need[i][j] > work[j])
    				{
    					break;
    				}
    			}
    			//已完全执行
    			if (j == resourseType)
    			{
    				Finish[i] = 1;
    				SafeInfo(work, i);
    				safeSeries[safeIndex++] = i;
    				//回收资源
    				for (j = 0; j < resourseType; j++)
    				{
    					work[j] += allocation[i][j];
    				}
    				goto NEXT;
    			}
    		}
    	}
    
    	int pNum = 0;
    	for (i = 0; i < customerNumber; i++)
    	{
    		if (Finish[i] == 0)
    		{
    			return 0;
    		}
    		else
    		{
    			pNum++;
    		}
    	}
    	//打印安全序列
    	printf("\n安全序列为:");
    	for (i = 0; i < customerNumber; i++)
    	{
    		if (isFinish(i))//统计没完全执行的进程数
    		{
    			pNum--;
    		}
    	}
    	for (i = 0; i < pNum; i++)
    	{
    		printf("%d ", safeSeries[i]);
    	}
    
    	return 1;
    }
    
    

    二、资源申请模块:

    //判断进程资源请求的安全性
    void judRequestSecurity()
    {
    	//输入预分配的资源编号和各类资源量
    	int curProcess;
    	printf("请输入预分配资源的进程的编号:");
    	scanf("%d", &curProcess);
    	getchar();
    
    	int i;
    	for (i = 0; i < resourseType; i++)
    	{
    		printf("请输入给 P%d 预分配的第 %d 类资源量:", curProcess, i + 1);
    		scanf("%d", &request[i]);
    		getchar();
    	}
    
    	//作为安全性的判断变量
    	num = 0;
    	//进行判断预分配是否合理
    	for (i = 0; i < resourseType; i++)
    	{
    		if (request[i] > need[curProcess][i])
    		{
    			printf("\n分配错误!请求分配资源量大于所需要的资源量!\n");
    			printf("\nRESOURCE INSECURITY!!!\n\nCUSTOMER P%d CAN NOT OBTAIN RESOURCES IMMEDIATELY\n\n", curProcess);
    			return;
    		}
    		else if (request[i] > available[i])
    		{
    			printf("\n分配错误!请求分配资源量大于可利用资源量!\n");
    			printf("\nRESOURCE INSECURITY!!!\n\nCUSTOMER P%d CAN NOT OBTAIN RESOURCES IMMEDIATELY\n\n", curProcess);
    			return;
    		}
    		else
    		{
    			num++;
    		}
    	}
    
    	//分配合理,则试探性地分配
    	if (num == resourseType)
    	{
    		num = 0;
    		for (i = 0; i < resourseType; i++)
    		{
    			available[i] -= request[i];
    			allocation[curProcess][i] += request[i];
    			need[curProcess][i] -= request[i];
    			if (need[curProcess][i] == 0)
    			{
    				num++;
    			}
    		}
    		//分配合理并且此次分配后该进程执行结束,回收资源
    		if (num == resourseType)
    		{
    			for (i = 0; i < resourseType; i++)
    			{
    				available[i] += allocation[curProcess][i];
    			}
    			printf("\n进程 P%d 执行完毕,所占用资源全部释放!\n", curProcess);
    		}
    		else
    		{
    			printf("\n进程 P%d 未执行完毕,等待\n", curProcess);
    		}
    	}
    
    	//检查分配后系统是否安全,如果不安全,则收回分配的资源
    	printf("\n------------------------------------------------------------------------------------\n");
    	printf("当前系统各类资源剩余量:");
    	for (int i = 0; i < resourseType; i++)
    	{
    		printf("%d ", available[i]);
    	}
    
    	printf("\n\n当前系统进程状况:\n");
    	printf(" Name\t Work\t Need\tAllocation\tWork+Allocation\t Finish\n");
    	if (!judSystemSecurity_1())
    	{
    		for (i = 0; i < resourseType; i++)
    		{
    			available[i] += request[i];
    			allocation[curProcess][i] -= request[i];
    			need[curProcess][i] += request[i];
    		}
    		printf("\n\nRESOURCE INSECURITY!!!\n\nCUSTOMER P%d CAN NOT  OBTAIN RESOURCES IMMEDIATELY", curProcess);
    	}
    	else
    	{
    		printf("\n\nRESOURCE SECURITY!!!\n\nCUSTOMER P%d CAN OBTAIN RESOURCES IMMEDIATELY", curProcess);
    	}
    	printf("\n------------------------------------------------------------------------------------\n");
    	return;
    }
    

    完整代码演示:

    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    //系统中每种资源的可利用资源数
    int available[100] = { 0 };
    //进程的最大需求资源数
    int max[100][100] = { 0 };
    //系统刚开始每个进程已占用资源数
    int allocation[100][100] = { 0 };
    //每个进程还需要的资源数
    int need[100][100] = { 0 };
    //判断每个进程是否安全
    int Finish[100] = { 0 };
    //安全序列号
    int safeSeries[100];
    //进程请求资源量
    int request[100];
    //资源计数变量,便于判断安全性
    int num;
    //系统当前可分配资源量
    int work[1000];
    //资源种类数和进程数
    int resourseType, customerNumber;
    //作为是否输入数据的判断变量
    int flag = 0;
    
    //函数声明
    int isFinish(int row);
    void SafeInfo(int* work, int index);
    int judSystemSecurity();
    int judSystemSecurity_1();
    void judRequestSecurity();
    void showMenu();
    void keyDown();
    void InitStastic();
    
    
    //函数定义
    int isFinish(int row)
    {
    	int j;
    	for (j = 0; j < resourseType; j++)
    	{
    		if (need[row][j] != 0)
    		{
    			return 0;
    		}
    	}
    	return 1;
    }
    
    //进程资源输出
    void SafeInfo(int* work, int index)
    {
    	int j;
    
    	printf(" P%d\t", index);
    	for (j = 0; j < resourseType; j++)
    	{
    		printf("%d ", work[j]);
    	}
    	printf("\t ");
    	for (j = 0; j < resourseType; j++)
    	{
    		printf("%d ", need[index][j]);
    	}
    	printf("\t  ");
    	for (j = 0; j < resourseType; j++)
    	{
    		printf("%d ", allocation[index][j]);
    	}
    	printf("\t  ");
    	for (j = 0; j < resourseType; j++)
    	{
    		printf("%d ", allocation[index][j] + work[j]);
    	}
    	printf("\t  T");
    	printf("\n");
    
    	return;
    }
    
    //方案二,利用goto语句
    int judSystemSecurity_1()
    {
    	int i, j;
    	for (i = 0; i < resourseType; i++)
    	{
    		work[i] = available[i];
    	}
    	for (i = 0; i < customerNumber; i++)
    	{
    		if (isFinish(i))
    		{
    			Finish[i] = 1;
    		}
    		else
    		{
    			Finish[i] = 0;
    		}
    	}
    
    	int safeIndex = 0;
    
    	NEXT:
    	for (i = 0; i < customerNumber; i++)
    	{
    		if (Finish[i] == 0)
    		{
    			for (j = 0; j < resourseType; j++)
    			{
    				if (need[i][j] > work[j])
    				{
    					break;
    				}
    			}
    			//已完全执行
    			if (j == resourseType)
    			{
    				Finish[i] = 1;
    				SafeInfo(work, i);
    				safeSeries[safeIndex++] = i;
    				//回收资源
    				for (j = 0; j < resourseType; j++)
    				{
    					work[j] += allocation[i][j];
    				}
    				goto NEXT;
    			}
    		}
    	}
    
    	int pNum = 0;
    	for (i = 0; i < customerNumber; i++)
    	{
    		if (Finish[i] == 0)
    		{
    			return 0;
    		}
    		else
    		{
    			pNum++;
    		}
    	}
    	//打印安全序列
    	printf("\n安全序列为:");
    	for (i = 0; i < customerNumber; i++)
    	{
    		if (isFinish(i))//统计没完全执行的进程数
    		{
    			pNum--;
    		}
    	}
    	for (i = 0; i < pNum; i++)
    	{
    		printf("%d ", safeSeries[i]);
    	}
    
    	return 1;
    }
    
    
    //判断系统的安全性
    int judSystemSecurity()
    {
    	int i;
    	//更新系统可利用资源量
    	for (i = 0; i < resourseType; i++)
    	{
    		work[i] = available[i];
    	}
    
    	int allFinish = 0;
    	//把未完成进程置为0
    	for (i = 0; i < customerNumber; i++)
    	{
    		//判断当前进程是否已经完成并且可以回收资源
    
    		//如果已经全部完成
    		if (isFinish(i))
    		{
    			Finish[i] = 1;
    			allFinish++;
    		}
    		else
    		{
    			Finish[i] = 0;
    		}
    	}
    
    	int r = 0;//表示当前要判断是否要进行预分配的进程的下标
    	int safeIndex = 0;//安全序列的下标
    	int temp = 0;//临时变量
    	int pNum = 0;//保存临时变量的个数
    	//预分配开始,当进程没有全部完成时,一直执行循环
    	while (allFinish != customerNumber)
    	{
    		num = 0;
    		//判断是否可以预分配
    		for (i = 0; i < resourseType; i++)
    		{
    			if (need[r][i] <= work[i] && Finish[r] == 0)//判断是否可以预分配
    			{
    				num++;
    			}
    		}
    
    		//可以预分配
    		if (num == resourseType)
    		{
    			//输出进程Pr的各项信息
    			SafeInfo(work, r);
    			//回收资源
    			for (i = 0; i < resourseType; i++)
    			{
    				work[i] = work[i] + allocation[r][i];
    			}
    			//完成的进程数增加
    			allFinish++;
    			//保存安全序列
    			safeSeries[safeIndex] = r;
    			safeIndex++;
    			//当前进程安全
    			Finish[r] = 1;
    		}
    
    
    		r++;//该式必须在此处	
    		if (r >= customerNumber)
    		{
    			r = r % customerNumber;
    			if (temp == allFinish)//temp记录的是上一次循环分配后所有的进程完成数,将上一次进程数跟这次预分配后的进程数
    			{					  //进行对比,如果相等,则是不安全的情况,直接break;否则是安全的情况,继续执行
    				break;
    			}
    			temp = allFinish;//更新完成的进程数
    		}
    		pNum = allFinish;//保存安全序列的个数
    	}
    
    	//判断系统是否安全
    	for (i = 0; i < customerNumber; i++)
    	{
    		if (Finish[i] == 0)
    		{
    			return 0;
    		}
    	}
    
    	//打印安全序列
    	printf("\n安全序列为:");
    	for (i = 0; i < customerNumber; i++)
    	{
    		if (isFinish(i))
    		{
    			pNum--;
    		}
    	}
    	for (i = 0; i < pNum; i++)
    	{
    		printf("%d ", safeSeries[i]);
    	}
    	return 1;
    }
    
    //判断进程资源请求的安全性
    void judRequestSecurity()
    {
    	//输入预分配的资源编号和各类资源量
    	int curProcess;
    	printf("请输入预分配资源的进程的编号:");
    	scanf("%d", &curProcess);
    	getchar();
    
    	int i;
    	for (i = 0; i < resourseType; i++)
    	{
    		printf("请输入给 P%d 预分配的第 %d 类资源量:", curProcess, i + 1);
    		scanf("%d", &request[i]);
    		getchar();
    	}
    
    	//作为安全性的判断变量
    	num = 0;
    	//进行判断预分配是否合理
    	for (i = 0; i < resourseType; i++)
    	{
    		if (request[i] > need[curProcess][i])
    		{
    			printf("\n分配错误!请求分配资源量大于所需要的资源量!\n");
    			printf("\nRESOURCE INSECURITY!!!\n\nCUSTOMER P%d CAN NOT OBTAIN RESOURCES IMMEDIATELY\n\n", curProcess);
    			return;
    		}
    		else if (request[i] > available[i])
    		{
    			printf("\n分配错误!请求分配资源量大于可利用资源量!\n");
    			printf("\nRESOURCE INSECURITY!!!\n\nCUSTOMER P%d CAN NOT OBTAIN RESOURCES IMMEDIATELY\n\n", curProcess);
    			return;
    		}
    		else
    		{
    			num++;
    		}
    	}
    
    	//分配合理,则试探性地分配
    	if (num == resourseType)
    	{
    		num = 0;
    		for (i = 0; i < resourseType; i++)
    		{
    			available[i] -= request[i];
    			allocation[curProcess][i] += request[i];
    			need[curProcess][i] -= request[i];
    			if (need[curProcess][i] == 0)
    			{
    				num++;
    			}
    		}
    		//分配合理并且此次分配后该进程执行结束,回收资源
    		if (num == resourseType)
    		{
    			for (i = 0; i < resourseType; i++)
    			{
    				available[i] += allocation[curProcess][i];
    			}
    			printf("\n进程 P%d 执行完毕,所占用资源全部释放!\n", curProcess);
    		}
    		else
    		{
    			printf("\n进程 P%d 未执行完毕,等待\n", curProcess);
    		}
    	}
    
    	//检查分配后系统是否安全,如果不安全,则收回分配的资源
    	printf("\n------------------------------------------------------------------------------------\n");
    	printf("当前系统各类资源剩余量:");
    	for (int i = 0; i < resourseType; i++)
    	{
    		printf("%d ", available[i]);
    	}
    
    	printf("\n\n当前系统进程状况:\n");
    	printf(" Name\t Work\t Need\tAllocation\tWork+Allocation\t Finish\n");
    	if (!judSystemSecurity_1())
    	{
    		for (i = 0; i < resourseType; i++)
    		{
    			available[i] += request[i];
    			allocation[curProcess][i] -= request[i];
    			need[curProcess][i] += request[i];
    		}
    		printf("\n\nRESOURCE INSECURITY!!!\n\nCUSTOMER P%d CAN NOT  OBTAIN RESOURCES IMMEDIATELY", curProcess);
    	}
    	else
    	{
    		printf("\n\nRESOURCE SECURITY!!!\n\nCUSTOMER P%d CAN OBTAIN RESOURCES IMMEDIATELY", curProcess);
    	}
    	printf("\n------------------------------------------------------------------------------------\n");
    	return;
    }
    
    //菜单
    void showMenu()
    {
    	printf("  ====================菜单栏=====================\n");
    	printf("\n\t       0、input datas\n");
    	printf("\n\t       1、judge the system security\n");
    	printf("\n\t       2、judge the request security\n");
    	printf("\n\t       3、quit\n");
    	printf("\n  ===============================================\n");
    	return;
    }
    
    //检测用户按键输入
    void keyDown()
    {
    NEXT:
    	;
    	int hit;
    	printf("请输入你的选择:");
    	scanf("%d", &hit);
    	switch (hit)
    	{
    	case 0:
    	NEXT_1:
    		flag = 1;
    		InitStastic();
    		break;
    	case 1://判断系统安全性
    		if (flag)
    		{
    			printf("\n------------------------------------------------------------------------------------\n");
    			printf("当前系统各类资源剩余量:");
    			for (int i = 0; i < resourseType; i++)
    			{
    				printf("%d ", available[i]);
    			}
    
    			printf("\n\n当前系统进程状况:\n");
    			printf(" Name\t Work\t Need\tAllocation\tWork+Allocation\t Finish\n");
    			if (judSystemSecurity_1())
    			{
    				printf("\n\nSYSTEM SECURITY!!!");
    			}
    			else
    			{
    				printf("\n\nSYSTEM  INSUFFICIENT!!!");
    			}
    			printf("\n------------------------------------------------------------------------------------\n");
    		}
    		else
    		{
    			printf("还未输入数据!请先输入相关数据\n");
    			goto NEXT_1;
    		}
    
    		break;
    	case 2://判断进程请求的安全性
    		if (flag)
    		{
    			judRequestSecurity();
    		}
    		else
    		{
    			printf("还未输入数据!请先输入相关数据\n");
    			goto NEXT_1;
    		}
    		break;
    	case 3://退出
    		printf("\n正常退出!\n");
    		exit(-1);
    	default:
    		printf("\n输入错误,请重新输入指令!\n");
    		system("pause");
    		system("cls");
    		showMenu();
    		goto NEXT;
    		break;
    	}
    }
    
    void InitStastic()
    {
    	printf("Input the type of resource and number of customer:\n");
    	scanf("%d%d", &resourseType, &customerNumber);
    	getchar();
    
    	printf("\nInput the amount of resource (maximum , allocated) of each customer:\n");
    	int i, j;
    	for (i = 0; i < customerNumber; i++)
    	{
    		for (j = 0; j < resourseType; j++)
    		{
    			printf("请输入进程 P%d 的第 %d 类资源的最大需求量:", i, j + 1);
    			scanf("%d", &max[i][j]);
    			getchar();
    		}
    		printf("\n\n");
    		for (j = 0; j < resourseType; j++)
    		{
    			printf("请输入进程 P%d 的第 %d 类资源的已占用资源量:", i, j + 1);
    			scanf("%d", &allocation[i][j]);
    			getchar();
    		}
    		printf("\n\n");
    		for (j = 0; j < resourseType; j++)
    		{
    			need[i][j] = max[i][j] - allocation[i][j];
    		}
    	}
    
    	printf("\nInput  the amout of  resources(available):\n");
    	for (i = 0; i < resourseType; i++)
    	{
    		printf("请输入第%d类资源的可利用量:", i + 1);
    		scanf("%d", &available[i]);
    		getchar();
    	}
    
    	printf("\n数据录入成功!\n");
    	return;
    }
    
    int main(int argc, char* argv[])
    {
    
    	while (1)
    	{
    		showMenu();
    		keyDown();
    		system("pause");
    		system("cls");
    	}
    
    	return 0;
    }
    

    菜单栏:
    在这里插入图片描述

    输入示例:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    输出示例:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    有任何问题可以留言交流,我一定及时回复

    展开全文
  • 可以通过银行家算法、随机分配算法和按序分配算法实现资源分配
  • (1)若进程P1请求资源,发出请求向量Request1(1,0,2),编写程序用银行家算法判断系统能否将资源分配给它; (2)若进程P2提出请求Request(0,1,0),用银行家算法程序验证系统能否将资源分配给它。
  • 银行家算法防止死锁。 二、实验目的 死锁会引起计算机工作僵死,造成整个系统瘫痪。因此,死锁现 象是操作系统特别是大型系统中必须设法防止的。通过本次实验,使 学生掌握死锁的概念和产生死锁的原因和必要条件,...
  • 本题主要内容是模拟实现资源分配。同时要求编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并使用适当的算法,有效的防止和避免死锁的发生。
  • 资源分配 银行家算法

    2011-06-03 08:15:59
    银行家算法 设计五个进程{P0,P1,P2,P3,P4}共享三类资源{A,B,C}的系统,{A,B,C}的资源数量分别为10,5,7。进程可动态地申请资源和释放资源,系统按各进程的申请动态地分配资源
  • 银行家算法模拟实验 班 级Gy计算机121 学 号 2012150261 姓 名 张凯 评语 成绩 指导教师_ 批阅时间 左 尹 月 日 一 实验目的与要求 目的用CC+城Java语言编写一个简单的银行家算法模拟程序用银行家算法实现资源分 ...
  • 主要为大家详细介绍了java实现简单银行家算法,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 银行家算法代码

    2016-11-10 09:53:43
    用C语言或C++编写一个简单的银行家算法模拟程序,用银行家算法实现资源分配。程序能模拟多个进程共享多种资源的情况。进程可动态地申请资源,系统按各进程的申请动态地分配资源。要求程序具有显示各进程的某一时刻的...
  • 银行家算法分配资源

    2011-12-17 17:16:26
    利用银行家算法分配系统资源,并判断系统是否安全
  • 其中进程可动态申请资源和释放资源,系统按各进程的申请动态的分配资源,要求采用银行家算法实现。 设计思想 本实验是基于Dijkstra的银行家算法的实现,该算法可用于在操作系统中避免死锁。 该算法的基本思想是:...
  • 银行家算法

    2018-11-23 17:00:56
    银行家算法实现资源分配。 设计五个进程{P0,P1,P2,P3,P4}共享三类资源{A,B,C}的系统,{A,B,C}的资源数量分别为 10,5,7。进程可动态地申请资源和释放资源,系统按各进程的申请动态地分配资源。要求程序...
  • 银行家算法java实现

    2018-01-02 20:16:07
    资源有三种,线程数为5,适合各种课程设计作业和参考学习
  • 银行家算法模拟实验

    2018-04-21 18:55:57
    银行家算法是从当前状态出发,逐个按安全序列检查各客户中谁能完成其工作,然后假定其完成工作且归还全部贷款,再进而检查下一个能完成工作的客户。如果所有客户都能完成工作,则找到一个安全序列,银行家才是安全的...
  • 银行家算法--进程调度算法--内存分配算法java实现
  • 银行家算法 :用户输入资源种类、进程、数资源数,再输入所需分配进程的编号以及资源个数,经过系统安全检查,判断是否安全,安全则分配成功,输出安全序列;不安全则分配失败 语言:C++ 运行环境:Visual Studio ...
  • #include &lt;string.h&gt; #include &lt;iostream.h&gt; #define FALSE 0 ...#define R 10 //最大资源种类数 int M ; //输入总进程数 int N ; //输入资源的种类数 int p[W]; ...



    #include <string.h>
    #include <iostream.h>
    #define FALSE 0 
    #define TRUE 1 
    #define W 4   //最大进程数W=4
    #define R 10   //最大资源种类数
    
    int M ;   //输入总进程数
    int N ;   //输入资源的种类数
    int p[W];
    
                  
    int ALL_RESOURCE[W];  //各类资源的总数量
    int AVAILABLE[R];     //可利用资源量
    int MAX[W][R];   //最大需求矩阵
    int ALLOCATION[W][R]; //分配矩阵,已占有的
    int NEED[W][R];       //还需要矩阵
    int Request[R];    //进程请求向量 
    
    
    void inputdata();    //数据输入    
    void showdata();       //数据显示  
    
    void changdata(int k);//进程请求资源数据改变
    
    void restoredata(int k); //数据恢复
    
    int  chksec(int s); //系统安全性的检测
    int  chkmax(int s); //检测最大需求   
      
    void bank();   //检测分配的资源是否合理
    void random();
          
    //数据输入
    void inputdata()
    {	
    	int i=0,j=0,p; 
    
       cout<<"请输入总进程数:"<<endl;
    
       do{
    	   cin>>M;
    	   if (M>W) cout<<endl<<"总进程数超过了程序允许的最大进程数,请重新输入:"<<endl;
       }while (M>W);//M大于W则重新循环
    
       cout<<endl;   
    
       cout<<"请输入资源的种类数:"<<endl;
       do {
    	   cin>>N;
    	   if (N>R)
    		cout<<endl<<"资源的种类数超过了程序允许的最大资源种类数,请重新输入:"<<endl;  
    		}while (N>R);
       cout<<endl;
    
       cout<<"请依次输入各类资源的总数量,即设置向量all_resource:"<<endl;
       for(i=0;i<N;i++)	  
    	   cin>>ALL_RESOURCE[i];
       cout<<endl;   
    
       cout<<"请依次输入各进程所需要的最大资源数量,即设置矩阵max:"<<endl;
       for (i=0;i<M;i++)
       {
          for (j=0;j<N;j++)
         {
            do {  
    			cin>>MAX[i][j];
    			if (MAX[i][j]>ALL_RESOURCE[j])//输入所需要各类资源数大于各类资源的总数量
    				cout<<endl<<"该最大资源数量超过了声明的该资源总数,请重新输入:"<<endl; 
    			}while (MAX[i][j]>ALL_RESOURCE[j]);
          }
       }
       cout<<endl; 
       
       cout<<"请依次输入各进程已经占据的各类资源数量,即设置矩阵allocation:"<<endl;
       for (i=0;i<M;i++)
       {
    	   for (j=0;j<N;j++)
    	   {
    		   do{	
    			   cin>>ALLOCATION[i][j];
    			   if (ALLOCATION[i][j]>MAX[i][j])
    					cout<<endl<<"已占有的资源数量超过了声明的最大资源数量,请重新输入:"<<endl;
    		   }while (ALLOCATION[i][j]>MAX[i][j]);
    	   }
       }
       cout<<endl;  
    
       //还需要的资源数量
       for (i=0;i<M;i++)
    	   for(j=0;j<N;j++)
    		   NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];   
    //	   
       for (j=0;j<N;j++)
       { 	
    	   p=ALL_RESOURCE[j];
    
    	   for (i=0;i<M;i++)
    	   {    
    		   p=p-ALLOCATION[i][j];  
    		   //此类资源还剩的资源数
               AVAILABLE[j]=p;
    
               if(AVAILABLE[j]<0)
    			   AVAILABLE[j]=0;
    	   }
       }
    }
    
    
    void showdata() 
    {  
       int i,j;    
       cout<<"各类资源的总数量,即向量all_resource为:"<<endl; 
       cout<<" "; 
    
       for (j=0;j<N;j++)
    	   cout<<" 资源"<<j<<": "<<ALL_RESOURCE[j]; 
    
       cout<<endl<<endl;
       
       cout<<"当前系统中各类资源中的可用数量,即向量available为:"<<endl; 
       cout<<" "; 
       for (j=0;j<N;j++)
    	   cout<<" 资源"<<j<<": "<<AVAILABLE[j]; 
       cout<<endl<<endl; 
    
       cout<<"各进程还需要的资源数量,即矩阵need为:"<<endl<<endl; 
       for (i=0;i<M;i++) 
       { cout<<"进程P"<<i<<":   "; 
         for (j=0;j<N;j++)
    		 cout<<NEED[i][j]<<"        "; 
         cout<<endl; 
       } 
       cout<<endl;  
       
       cout<<"各进程已经得到的资源量,即矩阵allocation为: "<<endl<<endl; 
       for (i=0;i<M;i++) 
       {	cout<<"进程P"<<i<<":    ";
    	   for (j=0;j<N;j++)
    		   cout<<ALLOCATION[i][j]<<"       "; 
    	   cout<<endl; 
       } cout<<endl; 
    } 
    
    //进程请求资源数据改变
    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 restoredata(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 chksec(int s) 
    {
    	int WORK,FINISH[W]; 
        int i,j,k=0; 
    	
        for(i=0;i<M;i++)
    		FINISH[i]=FALSE;
    	
        for(j=0;j<N;j++) 
    	{	
    		WORK=AVAILABLE[j];//可利用的资源数 
            i=s; //进程数
            do
    		{	
    			if(FINISH[i]==FALSE && NEED[i][j]<=WORK)
    			{
    				WORK=WORK+ALLOCATION[i][j]; 
    				FINISH[i]=TRUE; 
    				p[k]=i;
    				k++;
    				i=0; 
    			}
    			else 
    			{ 	
    				i++; 
    			} 
    		}while(i<M);
    
            for(i=0;i<M;i++) 
    			if(FINISH[i]==FALSE) 
    			{
    				return 1; 
    			} 
    	}  
    	return 0;             
    }
    
    //检测最大需求 
    int chkmax(int s)         
    {   
    	int j,flag=0;//flag不全为完成状态时的标志为0
    	for(j=0;j<N;j++) 
    	{
    		if (MAX[s][j]==ALLOCATION[s][j])
    		{   
    			flag=1;//全为完成状态时标志为1
    			AVAILABLE[j]=AVAILABLE[j]+MAX[s][j];
    			MAX[s][j]=0;
    		}
    	}	return flag;
    }
    
    //检测分配的资源是否合理
    void bank()
    {
         int i=0,j=0; 
         char flag='Y';      
         while(flag=='Y'||flag=='y') 
    	{ 
           i=-1; 
           while(i<0||i>=M) 
    	   { cout<<"请输入需申请资源的进程号(从P0到P"<<M-1<<",否则重新输入!):"; 
             cout<<"p";
    		 cin>>i; 
             if(i<0||i>=M)
    			 cout<<"输入的进程号不存在,重新输入!"<<endl; 
    	   } 
    	   cout<<"请输入进程P"<<i<<"申请的资源数:"<<endl; 
    
    	   
    	   for (j=0;j<N;j++) 
    	   { 	
    		   cout<<"  资源"<<j<<": "; 
    		   cin>>Request[j];
                if(Request[j]>NEED[i][j]) 
    		   {  
    			   cout<<"进程P"<<i<<"申请的资源数大于进程P"<<i<<"还需要"<<j<<"类资源的资源量!"<<endl; 
    			   //cout<<"申请不合理,出错!请重新输入<<endl; 
    				cout<<"申请不合理,出错!请重新输入"<<endl; 
    				j--;
    				continue;
    		   }
    		   
    		   
    		   else 
    		   {	
    			   if(Request[j]>AVAILABLE[j]) 
    			   {  
    				   cout<<"进程P"<<i<<"申请的资源数大于系统可用"<<j<<"类资源的资源量!"<<endl; 
    				   cout<<"申请不合理,出错!请重新输入"<<endl; 
    				   j--;
    				    continue;
    			   }
    		   } 
    	   
    		  
    		   
    	   } 
    	   
    	   if(flag=='Y'||flag=='y') 
    	   { 	
    		   changdata(i); 
    		   if(
    			   chksec(i)) 
    		   { 
    			   cout<<endl; 
    			   cout<<"该分配会导致系统不安全!!! 本次资源申请不成功,不予分配!!!"<<endl; 
    			   cout<<endl; 
    			   restoredata(i); 
    		   } 
    		    else		    
    		   {   cout<<endl; 
    				cout<<"经安全性检查,系统安全,本次分配成功,安全序列为:"<<endl; 
    				cout<<endl;
    				for(int k=0;k<M;k++)
    				{
    					cout<<p[k]<<endl;
    				}
    				cout<<"资源分配状况如下所示:"<<endl;
                       showdata(); 
    				if(chkmax(i))
    				{cout<<"在资源分配成功之后,由于该进程所需的某些资源的最大需求量已经满足,"<<endl;
    		cout<<"因此在进程结束后系统将回收这些资源!"<<endl;
      cout<<"在资源收回之后,各进程的资源需求和分配情况如下所示:"<<endl;
    					showdata(); 
    				}				
    		   }			  
    	   } 
    	   cout<<endl; 
    	   cout<<" 是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: "; 
    	   cin>>flag; } 
    }
    
    
    
    
    
    
    //随机分配算法
    
    void random()
    {
         int i=0,j=0; 
    	 int k;
         char flag='Y';      
         while(flag=='Y'||flag=='y') 
    	{ 
           i=-1; 
           while(i<0||i>=M) 
    	   { cout<<"请输入需申请资源的进程号(从P0到P"<<M-1<<",否则重新输入!):"; 
             cout<<"p";
    		 cin>>i; 
             if(i<0||i>=M)
    			 cout<<"输入的进程号不存在,重新输入!"<<endl; 
    	   } 
    	   cout<<"请输入进程P"<<i<<"申请的资源数:"<<endl; 
    	   for (j=0;j<N;j++) 
    	   { 	cout<<"  资源"<<j<<": "; 
    		   cin>>Request[j];
               if(Request[j]>NEED[i][j]) 
    		   {  cout<<"进程P"<<i<<"申请的资源数大于进程P"<<i<<"还需要"<<j<<"类资源的资源量!"; 
    			   cout<<"申请不合理,出错!请重新选择!"<<endl<<endl; 
    			   flag='N'; 
    			   break; 
    		   } 
    		   
    		 	if(Request[j]>AVAILABLE[j]) 
    			   {  cout<<"进程P"<<i<<"申请的资源数大于系统可用"<<j<<"类资源的资源量!"; 
    				   cout<<"申请不合理,出错!请重新选择!否则会产生死锁"<<endl<<endl; 
    				   flag='N'; 
    				   break; 
    			   } 
    	   }
    
                if(flag=='Y'||flag=='y') 
    			{ 
    				changdata(i); 
    			    showdata();
    		   break;
    		   }
    
    	   } 
    	
    }
    
    
    
    
       
    void main()
    {  
    	int n,r,i,j;
    	while(1)
    	{
    		cout<<"----------------资源分配-----------------"<<endl;
    	    cout<<"|    1.用银行家算法实现资源分配         |"<<endl;
    		cout<<"|    2.用随机分配算法实现资源分配       |"<<endl;
    		cout<<"-----------------------------------------"<<endl;
    		cout<<"请根据提示选择选择:"<<endl;
    		cin>>n;
    		switch(n)
    		{
    		case 1:
    		inputdata();   
    		for(i=0;i<M;i++)
       {	j=chksec(i);
    	   if (j==0) break;
       }   
       if (i>=M) 
    cout<<"错误提示:经安全性检查发现,系统的初始状态不安全!!!"<<endl;
       else
       {  cout<<"提示:经安全性检查发现,系统的初始状态安全!"<<endl;
         cout<<"安全序列为:"<<endl; 
    				for(int k=0;k<M;k++)
    				{
    					cout<<p[k]<<endl;
    				}
    	   bank();
       } 
    			cout<<"----------------------"<<endl;
    			break;
    		    case 2:
    	    	inputdata();  
    	    	random();
    			cout<<"----------------------"<<endl;		
    			break;
    		default:
    			return;
    		}
    	}
    }
    
    
    
    	   

    展开全文
  • 银行家算法分配资源的原则是:系统掌握每个进程对资源的最大需求量,当进程要求申请资源时,系统就测试该进程尚需资源的最大量,如果系统中现存的资源数大于或等于该进程尚需求资源最大量时,就满足进程的当前申请。...
  • 这是操作系统中的银行家算法,由于本人水平有限,故存在很多不足
  • 实现操作系统中经典的银行家算法银行家算法在为进程分配处理器等资源时,以预分配的策略,检测系统的安全性,若系统安全,系统予以分配;否则取消,返回预分配之前的结果。
  • 银行家算法实验报告

    2017-07-19 11:04:14
    银行家算法代码展示
  • C语言实现银行家算法

    2019-03-15 23:31:43
    使用C语言实现银行家算法,其中包括安全性算法和资源分配算法
  • 实验题目:用银行家算法和随机算法实现资源分配 实验原理: 银行家算法的分配资源是:当某个进程提出资源申请时,假定先分配资源给它,然后查找各进程的剩余请求,检查系统剩余资源量是否由于进程的分配而导致系统...
  • printf("\t\t\t* T0初始时刻资源分配情况 *\n"); printf("\t\t\t****************************************************\n"); printf("\t\t\t*Name Max Allocation Available*\n"); for(int i=1; i; i++) { ...
  • 共享资源分配银行家算法 计算机操作系统课程设计 资料由:若云№星辰提供
  • 仿真模拟银行家算法对死锁的避免。 所谓安全状态是指系统能按某种进程顺序,来为每个进程pi分配所需的资源,直至满足每个进程对资源的最大需求,使每个进程都可顺利地完成。如果系统无法找到这样一个序列,则系统...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,649
精华内容 5,859
关键字:

银行家算法资源分配表