操作系统之银行家算法的代码实现

最新推荐文章于 2024-07-17 23:40:39 发布
最新推荐文章于 2024-07-17 23:40:39 发布
阅读量2.5k 收藏 4
点赞数 1
分类专栏： 日常总结 文章标签： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ai_Math/article/details/106274471
版权

银行家算法

疫情 期间，上操作系统原理课，因为在家，所以上的浑浑噩噩，上周老师让提交银行家算法实验报告，自己看书弄了挺长时间的基本实现课本(汤小丹老师)上的案例，为了锻炼自己使用Markdown的能力，写下这篇文章。

1、银行家算法的详解

      这方面我就不多介绍(因为时间问题，来不及作图)，在csdn上看到几篇博客，写的很详细。

银行家算法详解(过程比较详细)
银行家算法流程图

2、银行家算法的代码实现

   按照课本上算法的描述实现算法的时候，自己起初出了一些问题。我们知道，银行家算法的核心
是安全性检查算法：当我们申请调用资源给某个进程 i 的时候，系统会先试探性地将资源分配给进程 i,
然后调用安全性检查算法，查询是此时是否存在安全序列，如果存在的话，那么表示这次资源的分配是没
有问题的，如果不存在安全序列，则表示此次资源的申请是危险的，回收已分配的资源，并让进程 i等待
1、改进
   首次实现算法的时候，在安全性算法那里与大多数人的想法一样，套用两次循环来寻找满足
条件(Finish[i]=0&&Work[i]<=Need[i][j])的进程,这样每返回一个可用进程下标的时候，总是会
在进程起始位置搜寻，坏的情况下，要进行n次if查询。虽然安全序列的不同·对于整个银行家算法的实现
并无影响，但是我们始终哟注重时间效率。我在安全性检查方面借助了队列和栈。这虽然在增加空间代价，
但是可减少判断的次数。
(1)、栈思路：第一次不满足条件的进程入栈，先进去的进程最后出来 设计两个栈，一个是“等待栈”，用于存放第一次查询的时候不满足条件的进程，如果不满足要求，就
将该进程的下标压入等待栈中。那么循环下来之后，如果栈满的话，可以判定没有安全序列，如果有的话
就从等待栈中Pop一个进程，再次查询，如果不满足的话，我们在建立一个“副等待栈”，这个栈可以单独
设立，也可以起初的时候把进程就放在栈中，那么一轮循环下来，进程栈就空了，这时候就可以当作副等待
栈了，处理过程与等待栈的处理过程和思路一样。
(2)、队思路：第一次不满足条件的进程入队，先进去的进程先出来

这个思路就用队的方式来解决，代码没有来得及编写，大致与栈一致

代码实现：代码不精，乱七八糟，正在努力

注：下面代码中有两个findindex函数，一个是用栈实现的，另一个是瞎写的。
当时看错算法内容了，以为是在安全性检查中，使不符合条件的进程等待。实际上无论安全性检查算法是怎么设计的，只要有安全序列就可以了。

#include<iostream>
using namespace std;
/*
*定义一个顺序栈
*/
typedef struct
{
	int *top;//栈顶指针
	int *base;//栈底指针
	int stacksize;//定义栈的大小
}SqStack;
/*
*初始化栈
*/
int initStack(SqStack &L,int n)
{//n代表栈的初始长度
	L.base = new int[n];
	if (!L.base)
		return 0;//如果创建栈失败，那么返回0
	L.top = L.base;//栈底与栈顶在同一位置，空栈
	L.stacksize = n;
	return 1;
}
/*
*Push 入栈,e代表被压入栈的内容
*/
int IsFull(SqStack L)
{
	if (L.top - L.base == 0)
		return 1;
	return 0;
}

//入栈
int Push(SqStack& L,int e)
{
	if (L.top-L.base==L.stacksize)
	{
		cout << "压栈失败,进程号:"<<e<< endl;
		return 0;//表示栈满
	}
	*L.top = e;
	L.top++;
	return 1;
}
//出栈
int Pop(SqStack& L, int &e)
{
	if (L.top - L.base == 0)
	{
		cout << "出栈失败，这是空栈" << endl;
		return 0;//这是空栈
	}
	L.top--;
	e = *L.top; 
	
	return 1;
}
//测试当前栈的实际长度
int getLength(SqStack L)
{
	return L.top - L.base;
}
#define Process_Num 5
#define Source_Num 3
int NUM = 0;
int Available[Source_Num] = { 3,3,2 };//this is available source_num
int Max[Process_Num][Source_Num] = {
{7,5,3},
{3,2,2},
{9,0,2},
{2,2,2},
{4,3,3}
};//this is the max source_num
int Allocation[Process_Num][Source_Num] =
{
{0,1,0},
{2,0,0},
{3,0,2},
{2,1,1},
{0,0,2}
};//this is the haved allocate source_num
int Need[Process_Num][Source_Num] =
{
{7,4,3},
{1,2,2},
{6,0,0},
{0,1,1},
{4,3,1}
};//这是当前进程所需要的资源的总数目
//int Request[Process_Num];//表示每个进程每次要申请访问的资源的数目
int Work[Source_Num];//在安全性检查算法中使用
int Finish[Process_Num];//安全性检查算法中使用，判断每个进程是否安全
int Resiger[Source_Num];//用于保存下标
/*******  函数区   *************/
int banker();//银行家算法
int isSafe();//安全性算法
int lh[Process_Num];//辅助数组
int findIndex();//在安全性检查算法中，寻找可以被分配资源的进程的下标
void show_one(int A[], int n);//打印一维函数所有值
int finish_true(int Finish[], int n);//判断安全性算法中的Finish函数是否全为true
int finish_false(int Finish[], int n);//判断安全性算法中的Finish函数是否全为false
int isEqual(int A[], int m, int B[]);//若对于任何 i B[i]>=A[i],return 1,否则返回0
void show_two();//显示函数
int find_zero(int A[], int m, int n);
int find_design(int A[], int n);
SqStack L1, L2, L;//L1:等待栈，L：存放进程栈，L2：进程栈的辅助栈
int main()
{

	if (banker() > -1)
		cout << "Successful,已经分配给进程。" << endl;
	int i, k;
	char m;
	do
	{
		k = banker();
		cout << endl;
		if (k >= 0 && finish_false(Need[k], Source_Num))
		{
			cout << "Successful 已经分配资源给进程 " << k << ",并且进程已完成并释放资源" << endl;
			for (int j = 0; j < Source_Num; j++)
			{
				Available[j] = Available[j] + Allocation[k][j];
				Allocation[k][j] = 0;
			}
			show_two();

		}
		else if (k >= 0 && !finish_false(Need[k], Source_Num))
		{
			cout << "Successful 已经分配资源给进程 " << k << ",但进程没有完成并释放资源" << endl;
			show_two();
		}
		else
			cout << "Default 分配资源给进程失败，请重新选择进程以及申请的资源" << endl;
		cout << "如果你想继续，请输入Y/y，否则输入N/n" << endl;
		cin >> m;
		if (m == 'Y' || m == 'y')
			i = 1;
		else if (m == 'N' || m == 'n')
			i = 0;
		cout << "******************************************" << endl;
	} while (i);
	return 0;
}
int  banker()
{//表示一次的进程进行资源申请，如果这次申请成功那么返回1，否则返回0
	int i, j, k, m;//i代表进程数,j代表资源地数目
	int Request[Source_Num];//作为临时数组
	show_two();
	cout << "正在检查T0时刻的安全性........" << endl;
	if (!isSafe())
	{
		cout << "T0时刻不安全，请重新分配......" << endl;
		exit(0);
	}
	cout << endl;
	printf("请输入请求资源的进程号 0--4，编号为:");
	cin >> i;
	m = i;
	cout << endl;
	printf("请输入进程 %d 要申请的各类资源的数目\n", i);
	cout << endl;
	for (j = 0; j < Source_Num; j++)
	{
		printf("第 %d 号资源申请数量:", j);
		cin >> Request[j];
		cout << endl;
	}
	cout << "Request请求资源数目为：" << endl;
	cout << "		A		B		C" << endl;
	show_one(Request, Source_Num);//打印数组
	cout << endl;
	/*判断该进程所申请资源的数量是否合理*/
	for (j = 0; j < Source_Num; j++)
		if (Request[j] > Need[i][j])
		{
			cout << "No:申请资源的数量超过进程最大需要的的数量" << endl;
			return -1;//如果申请错了，那么直接终止这次资源的申请
		}
	cout << "YES:申请资源的数量未超过进程最大需要的的数量" << endl;
	if (isEqual(Request, Source_Num, Available))
	{//表示request<Available
		for (j = 0; j < Source_Num; j++)
		{
			Available[j] = Available[j] - Request[j];
			Allocation[i][j] = Allocation[i][j] + Request[j];
			Need[i][j] = Need[i][j] - Request[j];
		}
		cout << "*************************************************" << endl;
		show_two();
		cout << "******************正在进行安全性检查*********************" << endl;
		if (!isSafe())
		{//表示此次分配不安全,就将已分配的资源恢复
			//表且还要将该进程等待
			for (j = 0; j < Source_Num; j++)
			{
				Available[j] = Available[j] + Request[j];
				Allocation[i][j] = Allocation[i][j] - Request[j];
				Need[i][j] = Need[i][j] + Request[j];
			}
			cout << "Sorry 当前申请不安全" << endl;
			return -1;
		}
		else
		{
			//show_two();
			return m;//表示此进程分配成功
		}
	}
	else
	{
		cout << "Default! 系统不能提供这么多资源" << endl;
		return -1;
	}


}
void show_one(int A[], int n)
{//这是一个打印出一维数组所有值的函数
	int i;
	if (n <= 0)
		return;
	cout << "		";
	for (i = 0; i < n; i++)
	{
		printf("%d		", A[i]);
	}
}
void show_two()
{
	int i, j;
	cout << "**************************************资源分配情况*******************************************" << endl;
	cout << "|	资源情况	work        allocation        need         Available   |" << endl;
	cout << "|	进程	      A  B  C        A  B  C        A   B   C	   A   B   C   |" << endl;
	for (i = 0; i < Process_Num; i++)
	{
		cout << "	" << i << "	    ";
		for (j = 0; j < Source_Num; j++)
		{
			cout << "  " << Max[i][j];
		}
		cout << "	   ";
		for (j = 0; j < Source_Num; j++)
		{
			cout << "  " << Allocation[i][j];
		}
		cout << "	 ";
		for (j = 0; j < Source_Num; j++)
		{
			cout << "   " << Need[i][j];
		}
		cout << "	";
		for (j = 0; j < Source_Num; j++)
		{
			if (i == 0)
				cout << "   " << Available[j];
		}
		cout << endl;
	}
}

int isSafe()
{
	int i;
	if (!initStack(L1, Process_Num))
	{
		cout << "Sorry!!! 等待栈L1初始化错误，程序即将退出" << endl;
		return -1;
	}
	if (!initStack(L, Process_Num))
	{
		cout << "Sorry!!! 进程栈L初始化错误，程序即将退出" << endl;
		return -1;
	}
	//为进程栈存放进程
	for (i = Process_Num - 1; i >= 0; i--)
		Push(L, i);//倒序压入进程栈中
	int j, k;//i 代表进程的计数器，j代表资源的计数器
	for (j = 0; j < Source_Num; j++)
		Work[j] = Available[j];
	for (i = 0; i < Process_Num; i++)
		Finish[i] = 0;
	cout << "安全序列:";
	while ((k = findIndex()) >= 0)
	{
		cout << k << "--->";
		for (j = 0; j < Source_Num; j++)
			Work[j] = Work[j] + Allocation[k][j];//释放资源
		Finish[k] = 1;
		if (finish_true(Finish, Process_Num))
		{//表示Finish全为true(1)
			delete[]L.base;
			delete[]L1.base;
			delete[]L2.base;
			return 1;//表示安全
		}
	}
	delete []L.base;
	delete []L1.base;
	delete []L2.base;
	return 0;//表示不安全

}
int findIndex()
{
	int i, j, e;
	while (!IsFull(L))
	{//这里是进程循环
		if (!Pop(L, i))
		{//从进程栈中取栈
			cout << "L栈出栈失败,进程号:" << i << endl;
			return -1;
		}
		j = 0;
		while (1)
		{//这里是资源循环,我们用j来判断资源能否满足进程i当j=Source_Num时，满足，小于时不满足
			if (Finish[i] == 0 && Need[i][j] <= Work[j])
				j++;
			else
			{
				//Pop(L, e);
				Push(L1,i);//压入栈中
				break;
			}
			if (j == Source_Num)
			{
				return i;
			}
		}
		if (j == Source_Num)
		{
			return i;
		}

	}
	//跳出上面while循环，表示进程栈L为空，那么此时我们需要检查等待栈的情况
	int n = getLength(L1);//nb表示等待栈的长度
	if (!initStack(L, n))
	{
		cout << "Sorry!!! 辅助栈L2初始化错误，程序即将退出" << endl;
		return -1;
	}
	while (!IsFull(L1) || getLength(L2) != n)
	{//此时等待栈中有进程在等待
		Pop(L1, i);//出栈并传递给i
		j = 0;
		while (1)
		{
			if (Finish[i] == 0 && Need[i][j] <= Work[j])
				j++;
			else
			{
				Push(L2, i);
			}
			
			if (j == Source_Num)
			{
				return i;
			}
		}
		if (j == Source_Num)
		{
			return i;
		}
		if (IsFull(L1) && getLength(L2) != n)
		{//此时表示，辅助栈未满而等待栈空闲
			Pop(L2, e);
			Push(L1, e);//这里作为一个调回
		}
	}
}
int isEqual(int A[], int m, int B[])
{//判断两个一维数组的的值是否相等，若A有一项大于B，返回0
//若B的任何一项都大于等于A中对应的，那么返回 1
	int i;
	for (i = 0; i < m; i++)
		if (A[i] > B[i])
			return 0;
	return 1;

}
int finish_true(int Finish[], int n)
{//判断finish数组的值是否全为 true,若是则返回 1,不是返回0
	int i;
	int k = 0;
	for (i = 0; i < n; i++)
	{
		if (Finish[i] == 1)
			k = k + 1;
		else
			k = k - 1;
	}
	if (k == 5)
		return 1;
	else
		return 0;
}
int finish_false(int Finish[], int n)
{//判断finish数组的值是否全为 true,若是则返回 1,不是返回0
	int i;
	int k = 0;
	for (i = 0; i < n; i++)
	{
		if (Finish[i] == 0)
			k = k + 1;
		else
			k = k - 1;
	}
	if (k == 5)
		return 1;
	else
		return 0;
}
/*
*findIndex @v2.0
*要求在某一个进程不能
*/
int findIndex_()
{//返回进程的编号
	int i, j, k, i_;
	i = 0;
	/*if (n == -1)//n就是上次的下标,如果为 -1表示这是第一次
		i = 0;
	else if (n == Process_Num - 1)
		i = 0;//表示最后一个完成，要开始第二轮的循环
	else if (n >= 0 || n < Process_Num - 1)
		i = n;*/
	i = find_design(Finish, Process_Num);
	while (i <= 4)
	{
		j = 0;//j作为资源的计数器，每一次都需要
		//k = find_design(lh, Process_Num);//k作为返回下
		while (1)
		{
			if (Finish[i] == 0 && Need[i][j] <= Work[j])
			{
				j++;
			}
			else {//如果当前按k不满足条件，置其在lh中为1
				//k = find_design(lh,Process_Num);
				//lh[i] = 1;
				break;//结束本次的循环
			}

			if (j == Source_Num)
			{
				return i;//返回进程的下标
			}
		}
		if (j == Source_Num)
		{
			return i;//返回进程的下标

		}
		i++;
	}
	return -1;
}
//在搜索下标函数中，如果在一次安全ixng算法A中
//进程i满足条件，那么下一次寻找时，开始的下标j要满足以下条件之一
//(1)j>i且j之后的进程没有被被释放
//(2)j=0
int find_design(int A[], int n)
{
	int i, j, index_r, num;
	index_r = -1;
	num = 0;


	for (i = 0; i < n; i++)
	{
		if (A[i] == 0 && A[n - 1] == 0)
		{
			index_r = i;
			if (find_zero(A, i, n - 1))
			{//表示I后面全为0，满足条件1
				break;
			}
		}
		if (A[i] == 0 && A[n - 1] == 1)
		{
			index_r = i;
			break;
		}

	}

	if (i == (Process_Num - 1) && A[i] == 0)
	{//表示已经搜寻一圈，到达最后一列
		for (j = 0; j < 3; j++)
			if (Need[i][j] <= Work[j])
				num++;
		if (num == 3)
		{
			//表示最后一个进程安全
			return i;//可以直接返回
		}
		else
		{//最后一个进程不安全，并且从头开始没有全为0的，那么从0开始，见到一个0
			//就返回
			/*if (!find_zero(A, 0, n - 1))
			{
				for (i = 0; i < n; i++)
					if (A[i] == 0)
						return i;
			}
			else*/
			return 0;

		}
	}

	if (index_r == -1)
	{
		cout << "没有找到,不满足条件1" << endl;
		return -1;
	}
	else
		return index_r;
}
int find_zero(int A[], int m, int n)
{//判断A数组，[m,n]之间内有没有全0，
	//如果有，返回 1.否则，返回 0；
	int i, j;
	j = 0;
	for (i = m + 1; i <= n; i++)
	{
		if (A[i] == 0)
			j++;
		else
			j--;

	}
	if (j != (n - m))
		return 0;
	else
		return 1;
}
Ai_Math
关注
专栏目录
操作系统银行家算法代码实现
05-30
银行家算法代码实现，是读者进一步了解银行家算法的使用
银行家算法源代码（操作系统）
05-06
这是一个银行家算法的源代码（操作系统），可以正确运行。
操作系统银行家算法代码
sunrise的博客
12-10 3429
主要函数： 1、void init()//初始化分配规则 2、bool isSafe()  //判断Finish序列是否满足安全要求 3、bool safe(int Need[][MAXRESOURSE],int Allocation[][MAXRESOURSE],int *Available) //当前分配是否满足安全性 4、void printSafeSieris()//输出安全序列 ...
一文搞懂银行家算法
最新发布
m0_62056231的博客
07-17 4288
死锁是指在计算机系统中，多个进程或线程因竞争资源或互相等待而陷入的一种永久阻塞的状态。互斥条件：某些资源在同一时间只能被一个进程使用。如果其他进程请求该资源，则必须等待。占有且等待条件：一个进程已经持有至少一个资源，但又请求新的资源，而新的资源正被其他进程持有，因此进程必须等待。不剥夺条件：资源不能被强行从一个进程中剥夺，必须由持有它的进程主动释放。循环等待条件：存在一个进程链，使得每个进程都在等待链中的下一个进程所持有的资源，形成一个环形等待链。
操作系统之银行家算法实现代码
热门推荐
易大飞
07-05 3万+
1. 算法思想银行家算法是为了避免死锁的算法，是Dijkstra的银行家算法。由于该算法用于实现银行系统现金贷款的发放而得名的。为实现银行家算法，系统中必须设置若干数据结构。1） 银行家算法的数据结构a) 可利用资源向量availableb) 最大需求矩阵c) 分配矩阵d) 需求矩阵2） 银行家算法设Requesti 是进程Pi的请求量，如果Requesti[j]=k,表示进程Pi需要K个Rj类型...
操作系统之银行家算法代码
StuTan
01-11 2046
银行家算法（Dijkstra, 1965）问题 一个银行家把他的固定资金（capital）贷给若干顾客。只要不出现一个顾客借走所有资金后还不够，银行家的资金应是安全的。银行家需一个算法保证借出去的资金在有限时间内可收回。 具体步骤如下： 假定顾客分成若干次进行；并在第一次借款时，能说明他的最大借款额。 顾客的借款操作依次顺序进行，直到全部操作完成； 银行家对当前顾客的借款操作进行判断，以确定其安...
操作系统银行家算法，C语言
03-31
操作系统中的银行家算法是一种资源分配和调度策略，用于预防死锁的发生。它是1965年由E.F.科德提出的一种安全算法，主要用于确保系统在分配资源时不会进入无法解除的死锁状态。该算法假设系统有一个中央调度者，它...
银行家算法实现（代码全面解析）
07-16
模拟实现Dijkstra的银行家算法以避免死锁的出现.分两部分组成: 第一部分:银行家算法(扫描) 1．如果Request,则转向2;否则,出错 2．如果Request,则转向3,否则等待 3．系统试探分配请求的资源给进程 4．系统...
用java实现操作系统实验银行家算法
05-26
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。 安全序列是指一个进程序列{P1，…，Pn}是安全的，即对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j )当前...
操作系统之银行家算法：从原理到实现的死锁避免教程
01-08
操作系统之银行家算法：从原理到实现的死锁避免教程 操作系统之银行家算法：从原理到实现的死锁避免教程 操作系统之银行家算法：从原理到实现的死锁避免教程 操作系统之银行家算法：从原理到实现的死锁避免教程 ...
操作系统实验报告C语言实现银行家算法.doc
06-29
【操作系统实验报告——C语言实现银行家算法】 银行家算法是一种用于避免操作系统死锁的经典策略，由艾兹格·迪杰斯特拉在1965年提出。在操作系统中，银行家算法通过模拟银行家对贷款的管理来合理地分配系统资源，...
银行家算法源代码（操作系统）银行家算法
04-26
银行家算法用c语言写的！希望对你的学习有用，不会写程序我们可以参考，但这只是开始我们要写下去，坚持!
操作系统之银行家算法源代码
01-20
银行家算法是避免死锁的一种重要方法，本程序用java编程语言对其进行了实现。 当用户申请一组资源时，系统必须做出判断，如果把这些资源分出去，系统是否还处于安全状态。 若是，就可以分出这些资源；否则，该申请暂不予满足。 1．数据结构 假设有M个进程N类资源，则有如下数据结构： MAX[M*N] M个进程对N类资源的最大需求量 AVAILABLE[N] 系统可用资源数 ALLOCATION[M*N] M个进程已经得到N类资源的资源量 NEED[M*N] M个进程还需要N类资源的资源量 2．银行家算法 设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。 (1)如果Request[N]<=NEED[I，N]，则转(2)；否则，出错。 (2)如果Request[N]<=AVAILABLE，则转(3)；否则，出错。 (3)系统试探分配资源，修改相关数据： AVAILABLE=AVAILABLE-REQUEST ALLOCATION=ALLOCATION+REQUEST NEED=NEED-REQUEST (4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。 3．安全性检查 (1)设置两个工作向量WORK=AVAILABLE；FINISH[M]=FALSE (2)从进程集合中找到一个满足下述条件的进程， FINISH[i]=FALSE NEED<=WORK 如找到，执行(3)；否则，执行(4) (3)设进程获得资源，可顺利执行，直至完成，从而释放资源。 WORK=WORK+ALLOCATION FINISH=TRUE GO TO 2 (4)如所有的进程Finish[M]=true，则表示安全；否则系统不安全。
银行家算法（c语言代码）
12-29
这是我参考了很多的同类代码后，自己写的一个实现银行家算法以及随机分配算法的c语言代码。这个代码符合操作系统课程设计有关银行家算法的实现。这是我的老师验收之后，并且修改过后的代码。欢迎大家下载。这个代码简单易懂，不复杂，适合大多数人使用。代码内注释较详细，更加方便读懂程序。
操作系统银行家算法源码
01-07
广工，操作系统实验，银行家算法，源码 2 实验要求 1. 假定系统有3类资源A（10个）、B（15个）、C（12个），系有5个进程并发执行，进程调度采用时间片轮转调度算法。 2. 每个进程由一个进程控制块（ PCB）表示，进程控制块可以包含如下信息：进程名、需要的资源总数、已分配的资源数、进程状态。 3. 由程序自动生成进程（包括需要的数据，要注意数据的合理范围）。 4. 进程在运行过程中会随机申请资源（随机生成请求的资源数），如果达到最大需求，表示该进程可以完成；如果没有达到最大需求，则运行一个时间片后，调度其它进程运行。资源分配采用银行家算法来避免死锁。 5. 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、阻塞B（Block）或完成F（Finish）状态之一。 6. 每进行一次调度，程序都要输出一次运行结果：正在运行的进程、就绪队列中的进程、阻塞队列中的进程、完成的进程以及各个进程的 PCB，以便进行检查。
操作系统银行家算法（JAVA/Python/C#/JavaScript/C/C++）代码实现
Meta.Qing的博客
09-28 2854
银行家算法是一种资源分配和死锁避免算法，它通过模拟所有资源的预定最大可能数量的分配来测试安全性，然后进行“s状态”检查以测试可能的活动，然后决定是否应该允许继续分配。这种算法要求分配的资源数量是固定的。它是一个大小为' n*m '的二维数组，定义了当前分配给每个进程的每种类型的资源数量。它是一个大小为' n*m '的二维数组，它定义了系统中每个进程的最大需求。它是一个大小为' n*m '的二维数组，表示每个进程所需的剩余资源。它是一个大小为' m '的一维数组，表示每种类型的可用资源的数量。
操作系统之银行家算法代码实现
TomlikeC的博客
12-15 1151
这个实验代码较为简单 不多说 直接上代码 #include<stdio.h> #include<stdlib.h> #define N 5 typedef struct { int A; int B; int C; }Resource; Resource Max[N]={{7,5,3}, {3,2,2}, {9,0,2}, ...
银行家算法实现（操作系统）附代码
匿名用户
11-30 2404
实验目的 　　银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。 　　在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。在这样的描述中，银行家就好比操作系统，资金就
C语言实现操作系统银行家算法
"银行家算法的C语言实现及其相关概念" 银行家算法是一种著名的死锁预防策略，...这个C语言代码实现了一个基本的银行家算法，用于在操作系统中管理资源分配，预防死锁，并展示了如何初始化和处理与算法相关的数据结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值