头歌实验5 银行家算法

最新推荐文章于 2023-11-23 21:00:11 发布
最新推荐文章于 2023-11-23 21:00:11 发布
阅读量1.4k 收藏 16
点赞数 8
文章标签： 算法 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70331091/article/details/134284920
版权

头歌实验5 银行家算法

任务描述

本关任务：编写银行家算法程序找出进程执行的安全序列。

相关知识

为了完成本关任务，你需要掌握：1.理解银行家算法原理，2.输出安全序列。

安全序列

并发运行的多个进程会竞争计算机资源，进程有多种可能的执行序列，不适宜的推进序列可能造成进程进入死锁状态，死锁严重影响计算机性能发挥。避免发生死锁的典型算法是Dijsktra银行家算法，它尝试找出一个进程的执行序列，使得所有进程都可以正常执行完毕。这个含有所有进程的序列就称为安全序列。

算法介绍

计算机系统允许进程并发执行及动态申请资源，但是并发运行的进程可能因资源分配顺序不合理而造成死锁。预防死锁是通过对运行中进程增加资源申请的限制条件，往往限制条件过多，不利于机器性能发挥。避免死锁通过寻找系统的安全状态能获得较好的系统性能，由 Dijkstra 发明的银行家安全算法是最具代表性的避免死锁的算法。

进程拥有若干数量资源，每个进程的成功执行后，因为系统回收资源使可用资源增加，从而使其它进程有更多可能性满足资源要求而得以执行。在当前资源数不能满足任何进程需求时，所有进程无法继续执行，进入死锁状态。银行家算法是对多种资源进行判断，试图找到一个进程执行序列，使所有进程执行完毕。

考虑只有一种资源的情况，当进程执行完毕，由于资源回收操作，系统总资源数会增加。如下图： 进程成功执行

银行家算法的问题条件是系统中存在n个进程和m种资源，m种资源用数量为m的数组表示，每个进程都可申请m种资源,每种资源数量不一。在初始情况时，资源向量 Available 表示每种资源可用总数，随着进程的申请与回收，资源数值产生动态变化，Available代表当前尚未分配出去的该类资源数量，Available[j]=K 表示当前系统中第j类资源剩余数量为K个。 每个进程申请的m种资源有最大数量值限制，当系统能满足其最大数量需求后，该进程能够正常运行完毕。将系统中n个进程的最大需求向量的用矩阵 Max 表示，它实际是n×m的二维数组。Max[i][j]=Q 表示第 i 个进程需要第 j 种资源最大数值为 Q向量。 银行家算法允许进程分多次动态申请资源而不是一次性分配最大值，使用 Allocation 矩阵表示某时刻资源分配情况，它也是 n×m 的二维数组， Allocation[i][j]= Ｐ表示第 i 个进程已经分配了第 j 种资源数值为Ｐ。由于分配不是一次性分配完成，进程可能还需要若干数量的资源，进程需要的资源数量用矩阵 Need 表示，它是 n×m 的二维数组，Need[i][j]=S 表示第i个进程还需第j种资源数值为Ｓ。而三个二维数组存在关系，它表示进程当前已经分配的资源数和最多需要的资源数与还需要的资源数间的关系。 Max[i][j]-Allocation[i][j]=Need[i][j] 银行家算法的目标是得到一个使所有进程依次运行完结的进程序列，当进程按指定顺序执行时，操作系统在每个进程的终结后都将其已分配资源回收，可用资源会增多，再将当前资源分配下去让后续进程正常执行，最终所有进程资源需求得到满足而全部执行完成，不发生死锁现象。由于进程总数为 n，进程的全排列总数为 n 的阶乘，只要在资源分配时验算资源申请是否满足系统要求即可得知当前排列是否可取，据此获得所有安全序列，这非常类似树的遍历，因此算法采用递归方式。 采用递归方式

银行家算法设计

安全序列的产生过程资源情况一直在发变化，定义一个包含当前可用资源数和现有进程序列的数据结构来表示算法的推进过程，并在每次选择进程时，申请新的内存空间，并复制现有资源信息，就可以为每个序列配上相应的资源变化情况。因为序列数量未知，当得到一个安全序列时，生成一个链表节点来保存，并将节点加入到链表中。

原始数据量较多，将数据先存入文件中，通过读文件的方式录入数据，并将字符转化为整数。数据在文件中的组织方式如下图所示。 数据组织 银行家算法是进程执行序列生成过程，由于进程组合序列可能性较多，采用递归的方法可以生成所有可能的进程序列，通过判断是否满足资源需求可确定该序列是否是安全的序列。为了方便进行在线结果检测，仅仅输出安全序列的个数。

主要函数说明：ReadBankData函数实现从文件中读入数据，初始化到相应数据结构中；BankerSecurity是核心的递归算法，最终生成所有的安全序列。递归生成过程中，随着进程序列推进序列不同，资源数据也在发生变化，每个序列的判断都必须有一个完整的当前资源信息，定义一个结构体表示当前资源信息。 每种不同的进程选择都采用malloc方式分配内存空间操作数据，使用完毕的内存空间还要通过free方法释放，直到所有进程都能执行完成即为一个安全序列。由于安全序列数量未知，得到一个安全序列后，创建一个链表节点，使用addSecueQtoLink方法将安全序列加入到链表中，最后getSecurePCount函数遍历链表得到安全序列的总数。

LineToInts是将一行字符串转化为整数组。CheckResource方法检测当前系统资源是否满足进程需要的数值。

编程要求

本实验采用 C 语言实现了银行家安全算法。根据缺失部分逻辑提示，补充合适的代码，使程序可以正常运行，得出正确结果。

代码展示
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

//系统当前可用资源和正在生成中的进程序列
typedef struct _ResAndP {
	int iAvailableRa;//系统当前资源A总数量
	int iAvailableRb;//系统当前资源B总数量
	int iAvailableRc;//系统当前资源C总数量 
	int iPOrder[5];//当前进程序列,最多5个
	int iPCount;  //进程队列中进程个数
}ResAndProcess;

//一个进程资源状态结构体
typedef struct _ResOfP {
	int iMaxRa;//进程需要A资源的最大数量
	int iMaxRb;//进程需要B资源的最大数量
	int iMaxRc;//进程需要C资源的最大数量 
	int iAllocRa;//进程已分配的A资源数量
	int iAllocRb;//进程已分配的B资源数量
	int iAllocRc;//进程已分配的C资源数量 
	int iNeedRa;//进程还需要的A资源数量
	int iNeedRb;//进程还需要的B资源数量
	int iNeedRc;//进程还需要的C资源数量
}ResOfProcess;

ResAndProcess StartResAndP;
ResOfProcess AllResOfP[5];


//链表节点结构体，保存一个安全序列
typedef struct POrder {
	int iPOrder[5];//安全的进程序列
	struct POrder* next;//下个节点指针
}POrderNode;


POrderNode* HeadOfPOrder;//序列链表的头指针 
//当前字符串转换到整数数组[5]
void LineToInts(char* lbuf, int* iArray, int iCount)
{
	char StrIntBuf[10];//将字符串转为整数的缓冲区 
	int i, j, iStrStart, iStrEnd, iStrLen, iProIndex;
	//17,5,20
	iStrLen = strlen(lbuf);
	i = 0;
	iStrEnd = 0;
	iStrStart = 0;
	for (j = 0; j < iCount; j++)
	{
		memset(StrIntBuf, 0, 10);
		for (; (i < iStrLen) && (lbuf[i] != ','); i++);
		iStrEnd = i;
		memcpy(StrIntBuf, lbuf + iStrStart, iStrEnd - iStrStart);
		iArray[j] = atoi(StrIntBuf);
		i++;
		iStrStart = i;
	}
}


//从banker.dat文件读入数据
int ReadBankData()
{
	/*
	FILE * fp=NULL;
	int fd = -1,i;
	ssize_t size = -1;
	char Linebuf[100];	 	/*存放数据的缓冲区*/
	/*
	char *pchar=NULL;
	char filename[] = "banker.dat";
	int  Numbers[6];//用于保存字符串转换的临时整数数组
	fp=fopen(filename,"r");
	if(fp==NULL)
	{//文件打开失败
		printf("Open file %s failure,fd:%d\n",filename,fd);
		return;
	}
	memset((void *)Linebuf,0,(size_t)100);//清空数组
	pchar=fgets(Linebuf,100,fp);
	LineToInts(Linebuf,Numbers,3);
	StartResAndP.iAvailableRa=Numbers[0];
	StartResAndP.iAvailableRb=Numbers[1];
	StartResAndP.iAvailableRc=Numbers[2];
	for(i=0;i<5;i++)
	{
		memset((void *)Linebuf,0,(size_t)100);//清空数组
		pchar=fgets(Linebuf,100,fp);
		LineToInts(Linebuf,Numbers,6);
		AllResOfP[i].iMaxRa=Numbers[0];
		AllResOfP[i].iMaxRb=Numbers[1];
		AllResOfP[i].iMaxRc=Numbers[2];
		AllResOfP[i].iAllocRa=Numbers[3];
		AllResOfP[i].iAllocRb=Numbers[4];
		AllResOfP[i].iAllocRc=Numbers[5];
		AllResOfP[i].iNeedRa=Numbers[0]-Numbers[3];
		AllResOfP[i].iNeedRb=Numbers[1]-Numbers[4];
		AllResOfP[i].iNeedRc=Numbers[2]-Numbers[5];
	}
	//关闭文件
	fclose(fp);
	*/

	/* 运行矩阵：
	Pi Maxa,Maxb,Maxc,Alloca,Allocb,Allocc,Needa,Needb,Needc,Avaia,Avaib,Avaic
	0  5,5,9,         2,1,2,               3,4,7,            1,5,2,
	1  5,3,6,         4,0,2,               1,3,4,
	2  4,0,11,        4,0,5,               0,0,6
	3  4,2,5,         2,0,4,               2,2,1
	4  4,2,4,         3,1,4,               1,1,0
	*/

	/*
	1,5,2,
	5,5,9,2,1,2,
	5,3,6,4,0,2,
	4,0,11,4,0,5,
	4,2,5,2,0,4,
	4,2,4,3,1,4,
	*/

	StartResAndP.iAvailableRa = 1;
	StartResAndP.iAvailableRb = 5;
	StartResAndP.iAvailableRc = 2;

	int i = 0;
	AllResOfP[i].iMaxRa = 5;
	AllResOfP[i].iMaxRb = 5;
	AllResOfP[i].iMaxRc = 9;
	AllResOfP[i].iAllocRa = 2;
	AllResOfP[i].iAllocRb = 1;
	AllResOfP[i].iAllocRc = 2;
	AllResOfP[i].iNeedRa = AllResOfP[i].iMaxRa - AllResOfP[i].iAllocRa;
	AllResOfP[i].iNeedRb = AllResOfP[i].iMaxRb - AllResOfP[i].iAllocRb;
	AllResOfP[i].iNeedRc = AllResOfP[i].iMaxRc - AllResOfP[i].iAllocRc;

	i = 1;
	AllResOfP[i].iMaxRa = 5;
	AllResOfP[i].iMaxRb = 3;
	AllResOfP[i].iMaxRc = 6;
	AllResOfP[i].iAllocRa = 4;
	AllResOfP[i].iAllocRb = 0;
	AllResOfP[i].iAllocRc = 2;
	AllResOfP[i].iNeedRa = AllResOfP[i].iMaxRa - AllResOfP[i].iAllocRa;
	AllResOfP[i].iNeedRb = AllResOfP[i].iMaxRb - AllResOfP[i].iAllocRb;
	AllResOfP[i].iNeedRc = AllResOfP[i].iMaxRc - AllResOfP[i].iAllocRc;

	i = 2;
	AllResOfP[i].iMaxRa = 4;
	AllResOfP[i].iMaxRb = 0;
	AllResOfP[i].iMaxRc = 11;
	AllResOfP[i].iAllocRa = 4;
	AllResOfP[i].iAllocRb = 0;
	AllResOfP[i].iAllocRc = 5;
	AllResOfP[i].iNeedRa = AllResOfP[i].iMaxRa - AllResOfP[i].iAllocRa;
	AllResOfP[i].iNeedRb = AllResOfP[i].iMaxRb - AllResOfP[i].iAllocRb;
	AllResOfP[i].iNeedRc = AllResOfP[i].iMaxRc - AllResOfP[i].iAllocRc;

	i = 3;
	AllResOfP[i].iMaxRa = 4;
	AllResOfP[i].iMaxRb = 2;
	AllResOfP[i].iMaxRc = 5;
	AllResOfP[i].iAllocRa = 2;
	AllResOfP[i].iAllocRb = 0;
	AllResOfP[i].iAllocRc = 4;
	AllResOfP[i].iNeedRa = AllResOfP[i].iMaxRa - AllResOfP[i].iAllocRa;
	AllResOfP[i].iNeedRb = AllResOfP[i].iMaxRb - AllResOfP[i].iAllocRb;
	AllResOfP[i].iNeedRc = AllResOfP[i].iMaxRc - AllResOfP[i].iAllocRc;

	i = 4;
	AllResOfP[i].iMaxRa = 4;
	AllResOfP[i].iMaxRb = 2;
	AllResOfP[i].iMaxRc = 4;
	AllResOfP[i].iAllocRa = 3;
	AllResOfP[i].iAllocRb = 1;
	AllResOfP[i].iAllocRc = 4;
	AllResOfP[i].iNeedRa = AllResOfP[i].iMaxRa - AllResOfP[i].iAllocRa;
	AllResOfP[i].iNeedRb = AllResOfP[i].iMaxRb - AllResOfP[i].iAllocRb;
	AllResOfP[i].iNeedRc = AllResOfP[i].iMaxRc - AllResOfP[i].iAllocRc;

	return 1;
}

//检查安全序列集回安全序列个数				
int getSecurePCount()
{
	int SecuPCount = 0;
	int i = 0;
	POrderNode* curNode = NULL;
	//释放所有节点 
	while (HeadOfPOrder != NULL)
	{
		SecuPCount++;//为了方便在线检测，这里仅获得安全序列个数 
		curNode = HeadOfPOrder;
		//根据需要也可以输出安全序列，去掉注释符号即可输出安全序列 //printf("安全序列是：%d,%d,%d,%d,%d.\n",curNode->iPOrder[0],curNode->iPOrder[1],curNode->iPOrder[2],curNode->iPOrder[3],curNode->iPOrder[4]); 
		HeadOfPOrder = HeadOfPOrder->next;
		free((void*)curNode);
	}
	return SecuPCount;
}

//检查当前资源条件，序号为iPIndex的进程资源需求是否可以分配资源
int CheckResource(ResAndProcess* aRAndP, int iPIndex)
{
	int iResult = 0;
	//iPIndex为进程序列中的序号 
	//Available>=Need，则返回值1
	//给出iPIndex编号的进程是否可以分配资源的判断逻辑
	/*  begin ******************************************************** */

	if (aRAndP->iAvailableRa >= AllResOfP[iPIndex].iNeedRa &&
		aRAndP->iAvailableRb >= AllResOfP[iPIndex].iNeedRb &&
		aRAndP->iAvailableRc >= AllResOfP[iPIndex].iNeedRc) {
		iResult = 1;
	}

	/*   end  ************************************************************** */
	//如果不满足要求会返回0值
	return iResult;
}

//银行家安全算法递归算法，得到所有安全序列，
void BankerSecurity(ResAndProcess* curRAndP)
{
	int i = 0, j = 0;
	int iDxDontInQue = 1;
	int iNewPOrder = 0;
	ResAndProcess* tmpP;
	//请在begin end语句间补判断语句
//判断逻辑是当前生成的进程序列已达到满序列，表示全部进程可以执行完成
/*  begin *******************程序代码一行******************************* */
	if (curRAndP -> iPCount == 5)
		/*   end  ************************************************************** */
	{
		//将当前安全序列添加到链表中
		//创建一个安全序列的节点指针
		//将一个安全的进程序列拷贝到添加到链表中添加到链表中
		//注意不同平台的int字节数不同，要使用sizeof(int)确定长度
		//因curRAndP节点会被回收，所以要将值拷贝到oneNode节点
		//将当前安全序列添加到链表头。
		//请根据上述提示补上相应功能的代码
		/*  begin *******************程序代码四行******************************* */

		POrderNode* oneNode;
		oneNode = (POrderNode*)malloc(sizeof(POrderNode));
		for (int i = 0; i < 5; i++) {
			oneNode->iPOrder[i] = curRAndP->iPOrder[i];
		}
		oneNode->next = HeadOfPOrder;
		HeadOfPOrder = oneNode;

		/*   end  ************************************************************** */
		//递归到此结束，开始回退
		return;
	}
	else {
		//取下面可能的进程编号继续下层递归
		for (i = 0; i < 5; i++)
		{
			iDxDontInQue = 1;
			//检查当前进程序号是否在队列中
			for (j = 0; j < curRAndP->iPCount; j++)
			{
				if (i == curRAndP->iPOrder[j])
				{//找到下标则表示i在当前队列中
					iDxDontInQue = 0;
					break;
				}
			}
			//请编写逻辑，实现递归生成安全序列的代码，注意内存的申请和回收
			/*  begin *******************程序代码约十二行******************************* */

			if (iDxDontInQue == 1 && CheckResource(curRAndP, i)) {
				ResAndProcess* tmpP = (ResAndProcess*)malloc(sizeof(ResAndProcess));
				for (int k = 0; k < 5; k++) {
					tmpP->iPOrder[k] = curRAndP->iPOrder[k];
				}
				tmpP->iAvailableRa = curRAndP->iAvailableRa - AllResOfP[i].iNeedRa + AllResOfP[i].iMaxRa;
				tmpP->iAvailableRb = curRAndP->iAvailableRb - AllResOfP[i].iNeedRb + AllResOfP[i].iMaxRb;
				tmpP->iAvailableRc = curRAndP->iAvailableRc - AllResOfP[i].iNeedRc + AllResOfP[i].iMaxRc;
				tmpP->iPCount = curRAndP->iPCount + 1;
				tmpP->iPOrder[tmpP->iPCount - 1] = i;
				BankerSecurity(tmpP);
				free(tmpP);
			}

			/*   end  ************************************************************** */
		}
	}
}


int main(void)
{
	int iSqcount = 0;
	//初始化数据,安全序列链表初始为空 
	HeadOfPOrder = NULL;
	//读入文件数据
	if (ReadBankData())
	{
		ResAndProcess* initResAndPro = (ResAndProcess*)malloc(sizeof(ResAndProcess));
		//请在begin end语句间补全程序语句实现对initResAndPro赋初值操作 
		/*  begin *******************程序代码约四行******************************* */

		initResAndPro->iAvailableRa = StartResAndP.iAvailableRa;
		initResAndPro->iAvailableRb = StartResAndP.iAvailableRb;
		initResAndPro->iAvailableRc = StartResAndP.iAvailableRc;
		initResAndPro->iPCount = 0;

		/*   end  ************************************************************** */

		//启动银行家算法
		BankerSecurity(initResAndPro);
		//得到安全序列的个数(或者输出全部安全序列)
		iSqcount = getSecurePCount();
		if (iSqcount > 0)
		{
			printf("%d", iSqcount);

		}
		else {
			printf("未找到安全序列。");
		}
	}
	else {
		//文件数据读取失败则输出0
		printf("banker.dat文件读取失败。");
	};
	return 0;
}
效果图

在这里插入图片描述

恭喜你挑战成功！
烦躁的黄色汉堡诶
关注
  • 8
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
【操作系统】基于c语言的银行家算法模拟实现
学吧 太深了
03-27 1689
基于C语言的银行家算法模拟实现源码
银行家算法代码
11-10
用C语言或C++编写一个简单的银行家算法模拟程序，用银行家算法实现资源分配。程序能模拟多个进程共享多种资源的情况。进程可动态地申请资源，系统按各进程的申请动态地分配资源。要求程序具有显示各进程的某一时刻的资源分配表和安全序列；显示各进程依次要求申请的资源数量以及为某进程分配资源后的有关资源数据的情况。
操作系统实验二——银行家算法
08-29
死锁会引起计算机系统的瘫痪。银行家算法是在实现资源分配时避免死锁 的一个著名算法，该算法是在能确保系统处于安全状态时才把资源分配给申请者。 本设计的目的是通过编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用适当的算法，有效地防止和避免死锁的发生。
操作系统实验之银行家算法
05-22
包含例子及相关代码 银行家算法 一，实验目的 1，掌握银行家安全性算法和资源请求算法的原理 2，掌握银行家算法的实现方法 二，基本概念 在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。在这样的描述中，银行家就好比操作系统，资金就是资源，客户就相当于要申请资源的进程。 银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。为实现银行家算法，系统必须设置若干数据结构。 安全序列是指一个进程序列{P1，…，Pn}是安全的，即对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
头歌实验7：处理机调度与死锁--银行家算法
qq_62791684的博客
11-21 2975
处理机调度与死锁--银行家算法
操作系统银行家算法避免死锁
06-17
银行家算法避免死锁 VM软件 Linux系统 C语言 成功编译 成功运行 内附完整课设报告，代码，运行cpp 附有哲学家进餐简略一题 原课设要求：死锁避免 （1）请设计一个程序演示死锁避免算法（银行家算法）。 （2）要求该演示程序可以指定任意的进程数量、资源种类、每种资源总数量（大于等于1）、已分配数量、最大需求数量，同时也可以随机生成上述数值进行模拟（随机生成可以设定范围，但是要求多次运行能体现随机生成而非静态预设）。 （2）要求该演示程序能显示各进程申请和释放资源以及系统动态分配资源的过程，便于用户观察和分析。 （3）如果系统可以正常分配资源，最终应输出所有可能的安全序列；如果系统不能分配，应给出无法找到安全序列的提示并输出最终到达的死锁状态（含已分配矩阵、最大需求矩阵、剩余可分配资源等） （4）另选择一种死锁避免的方法进行实现，完成整个过程。如哲学家就餐、生产者-消费者或者读者-写者问题等。 （5）要求在linux ubuntu环境下使用c/c++编写
操作系统第三章：银行家算法
你说的白是什么白_
10-22 2万+
文章目录银行家算法1. 银行家算法中的数据结构2. 银行家算法的处理步骤3. 安全性算法4.举例5.银行家算法总结 银行家算法 银行家算法是最有代表性的避免死锁的算法。 由于该算法能用于银行系统现金贷款的发放而得名的。 1. 银行家算法中的数据结构 设系统中有m类资源，n个进程 （1）可利用资源向量Available。含有m个元素的一维数组，每个元素代表一类可利用的资源数目。 如果Available[j]=k,表示系统中现有Rj类资源k个。 （2）最大需求矩阵Max， 是一个n*m的矩阵，定义了系统中n个
本关任务：编写银行家算法程序找出进程执行的安全序列。
m0_68607307的博客
11-08 252
* begin *******************程序代码约四行******************************* *//* begin *******************程序代码四行******************************* *//* begin *******************程序代码一行******************************* *///请编写逻辑，实现递归生成安全序列的代码，注意内存的申请和回收。/*存放数据的缓冲区*/
头歌操作系统实训总结
最新发布
荆鹏的博客
11-23 1763
6、银行家算法中的数据结构包括可用资源向量Available、最大需求矩阵Max、分配矩阵Allocation、需求矩阵Need，下列选项中表述正确的是（B）。1、系统出现死锁时一定同时保持了四个必要条件，对资源采用按序分配算法后可破坏的条件是（A）。4、为了避免系统可能出现死锁，分配资源可以采用的算法是（D）。5、某系统采用了银行家算法，则下列说法正确的是（C）。2、资源的静态分配算法在解决死锁问题中是用于（B）。7、下列选项中，属于检测死锁的方法是（A）。8、下列选项中，属于解除死锁的方法是（B）。
头哥算法答案及解析
m0_51930376的博客
03-04 1万+
目录实验1第1关：数字统计问题第2关：字典序第3关：兔子问题(求斐波那契数列前200项)实验二 实验1 第1关：数字统计问题 本关任务：一本书的页码从自然数1开始编码直到自然数n。书的页码按照通常的习惯编排，每个页码都不含多余的前导数字0. 例如，第8页用数字8表示，而不是08或者008之类。 数字统计问题要求对给定书的总页码n，计算出书的全部页码中分别出现了多少次数字0，1，2，…,9。 #include<stdio.h> #include<math.h> #include<
银行家算法-模拟预防和避免死锁的处理过程
05-22
以经典的避免死锁算法（银行家算法）为设计背景，模拟预防和避免死锁的处理过程
银行家算法-----一个n个并发进程共享m个资源的银行家算法的模拟实现
01-07
(1) 简单的交互界面 (2) 能显示当前系统资源的剩余情况和占用情况 (3) 能输入每个进程的最大资源要求 模拟利用银行家算法为进程的若干次资源请求分配资源 (4) 输入本次资源要求； (5) 按银行家算法为进程分配资源，本次分配是否成功要显示出来(要能处理各种情况：可以满足这次请求、由于资源不够不能满足这次请求、由于可能产生不安全不能满足这次请求、请求不合理拒绝请求等) (6) 作业撤销时要回收资源
银行家算法的思想，编写程序，解决并发进程的死锁问题。
11-30
根据银行家算法的思想，编写程序，解决并发进程的死锁问题。 本实验要求设计并实现银行家算法。银行家算法是死锁避免的经典算法，其核心思想是：进程动态地申请资源，每次申请资源时系统都执行安全状态检查算法判断本次申请是否会造成系统处于不安全状态，如果不安全则阻塞进程；如果安全状态，则完成资源分配。 安全状态检查算法的思想是找到一个安全序列，使所有进程都能执行完毕。如果找到，则处于安全状态，否则为不安全状态。
操作系统实验报告C语言实现银行家算法.doc
06-29
操作系统实验报告C语言实现银行家算法
银行家算法实验报告.docx
11-18
操作系统实验银行家算法具体实验数据和源代码
操作系统实验二：银行家算法
05-31
内含实验报告+代码（源代码+可执行文件）+截图
c++ 银行家算法【操作系统】
weixin_38054086的博客
05-10 220
#include<iostream> #include <fstream> #include <queue> #include<list> using namespace std; #define NUMOFPROGRESS 5 #define KINDOFSOURCE 3 class Banker { private: int max[NUMO...
操作系统实验：银行家算法C语言实现
qq_45811908的博客
05-29 3497
银行家算法C语言实现 #include<stdio.h> #include<stdlib.h> #define ok 1 #define true 1 #define false 0 int claim[100][100] = {0}; // 各个进程需要的最大资源数量 int alloc[100][100] = {0}; // 各个进程已分配的资源数量 int need[100][100] = {0}; // 各个进程还需要的资源数量 int resource[100] = {
操作系统实验2 银行家算法
热门推荐
一半西瓜的博客
04-28 2万+
【实验名称】银行家算法 【实验目的】 1.加深了解有关资源申请、避免死锁等概念； 2.体会和了解死锁和避免死锁的具体实施方法； 3.掌握银行家算法，设计实验数据验证其分配策略。 【实验原理】 银行家算法设置以下四个数据结构: 1.可利用资源向量Available:其初始值是系统中所配置的该类全部可用资源的数目。 2.最大需求矩阵M...
死锁实验二银行家算法
11-16
银行家算法是一种避免死锁的算法，它通过动态地分配资源来避免死锁的发生。在实验二中，我们需要编写一个简单的模拟程序来演示银行家算法的工作原理。以下是一个Python实现的示例程序： ```python # 定义资源数量和进程数量 num_resources = 3 num_processes = 5 # 定义可用资源向量 available = [3, 3, 2] # 定义最大需求矩阵 max_matrix = [ [7, 5, 3], [3, 2, 2], [9, 0, 2], [2, 2, 2], [4, 3, 3] ] # 定义已分配矩阵 allocation_matrix = [ [0,1, 0], [2, 0, 0], [3, 0, 2], [2, 1, 1], [0, 0, 2] ] # 定义需求矩阵 need_matrix = [ [7, 4, 3], [1, 2, 2], [6, 0, 0], [0, 1, 1], [4, 3, 1] ] # 定义安全序列列表 safe_sequence = [] # 定义工具函数，判断当前状态是否安全 def is_safe(processes, available, allocation, need): work = available.copy() finish = [False] * len(processes) while False in finish: found = False for i in range(len(processes)): if not finish[i] and all(x >= 0 for x in [y - z for y, z in zip(need[i], work)]): finish[i] = True work = [x + y for x, y in zip(work, allocation[i])] safe_sequence.append(processes[i]) found = True if not found: return False return True # 定义主函数，执行银行家算法 def banker(processes, available, allocation, need): if is_safe(processes, available, allocation, need): print("Safe sequence: ", safe_sequence) return True else: print("Unsafe state!") return False # 执行主函数 processes = [i for i in range(num_processes)] banker(processes, available, allocation_matrix, need_matrix) ``` 该程序中，我们首先定义了资源数量和进程数量，以及可用资源向量、最大需求矩阵、已分配矩阵和需求矩阵。然后，我们定义了一个工具函数is_safe，用于判断当前状态是否安全，以及一个主函数banker，用于执行银行家算法。最后，我们执行主函数，并输出安全序列。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值