操作系统（银行家算法）

最新推荐文章于 2023-04-16 20:01:55 发布
最新推荐文章于 2023-04-16 20:01:55 发布
阅读量198 收藏
点赞数
分类专栏： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44169557/article/details/107049280
版权

银行家算法

  • 安全性检测
  • 资源申请
/***********************************************************
* 版权所有 (C)2020, Liuzhihan
*
* 文件名称： os.cpp 
* 文件标识：无
* 内容摘要：银行家算法安全性检查，进程申请资源 
* 其它说明：无
* 当前版本： V3.0
* 作   者：刘志涵 
* 完成日期： 20200701
*
**********************************************************/

#include <bits/stdc++.h>

using namespace std;
const int N = 100;

const int total_resources = 3; //资源总数

struct process
{
	/* data */
	int resources_max[total_resources];		   //每种资源的总大需求量
	int resources_allocation[total_resources]; //已分配的资源
	int resources_need[total_resources];	   //还需要的各类资源数
	/* need = max - allocation */
	bool finished;
};

int resources_available[total_resources]; //可分配的资源

int cnt_process;	   //总进程个数
int remaining_process; //未完成的进程个数
vector<process> p;	   //各进程数据

int State;
int request[total_resources]; //请求向量

int work[total_resources];
bool finished[N];
int sequence[N];
bool result;

/*********************************************************
* 功能描述：检查当前进程是否可以获取需要的资源need 
* 输入参数：cur - 进程号 
* 输出参数：true - 可以
			false - 不可以 
* 返回值：无 
* 其它说明：无 
************************************************************/
bool check(int cur)
{
	for (int i = 0; i < total_resources; i++)
	{
		if (p[cur].resources_need[i] > work[i])
			return false;
	}
	return true;
}

/*********************************************************
* 功能描述：dfs时选取下一个进程后 可分配资源减变化 
* 输入参数：i - 进程号 
* 输出参数：无 
* 返回值：无 
* 其它说明：无 
************************************************************/
void nextWork(int i)
{
	for (int j = 0; j < total_resources; ++j)
	{
		work[j] += p[i].resources_allocation[j];
	}
	finished[i] = true;
}

/*********************************************************
* 功能描述：dfs时返回后 可分配资源的前一状态 
* 输入参数：i - 进程号 
* 输出参数：无 
* 返回值：无 
* 其它说明：无 
************************************************************/
void prevWork(int i)
{
	for (int j = 0; j < total_resources; ++j)
	{
		work[j] -= p[i].resources_allocation[j];
	}
	finished[i] = false;
}

/*********************************************************
* 功能描述：显示可分配资源 Available
* 输入参数：无
* 输出参数：无 
* 返回值：无 
* 其它说明：无 
************************************************************/
void show_available()
{
	cout << endl;
	cout << "Available" << endl;
	for (int i = 0; i < total_resources; ++i)
	{
		if (i)
			cout << "   ";
		cout << "R" << i + 1;
	}
	cout << endl;
	for (int i = 0; i < total_resources; ++i)
	{
		if (i)
			cout << "    ";
		cout << resources_available[i];
	}
	cout << endl
		 << endl;
}

/*********************************************************
* 功能描述：显示安全序列 
* 输入参数：无
* 输出参数：无 
* 返回值：无 
* 其它说明：无 
************************************************************/
void show_sequence()
{
	vector<int> v(total_resources);
	for (int i = 0; i < total_resources; ++i)
	{
		v[i] = resources_available[i];
	}

	cout << "       MAX  "
		 << "  Allocation"
		 << "  Need  "
		 << "  Available" << endl;
	for (int i = 0; i < cnt_process; ++i)
	{
		cout << "P" << sequence[i] + 1 << "   ";
		for (int j = 0; j < total_resources; ++j)
		{
			cout << " " << p[sequence[i]].resources_max[j];
		}
		cout << "    ";
		for (int j = 0; j < total_resources; ++j)
		{
			cout << " " << p[sequence[i]].resources_allocation[j];
		}
		cout << "    ";
		for (int j = 0; j < total_resources; ++j)
		{
			cout << " " << p[sequence[i]].resources_need[j];
		}
		cout << "    ";
		for (int j = 0; j < total_resources; ++j)
		{
			v[j] += p[sequence[i]].resources_allocation[j];
			cout << " " << v[j];
		}
		cout << endl;
	}
	cout << endl;
}

/*********************************************************
* 功能描述：dfs求安全序列 
* 输入参数：cnt - 可以分配资源的进程个数 
* 输出参数：无 
* 返回值：无 
* 其它说明：无 
************************************************************/
void dfs(int cnt)
{
	if (result) return; //注释这一行就可输出所有的安全序列
	if (cnt == cnt_process)
	{
		for (int i = 0; i < cnt; ++i)
		{
			if (i)
				cout << " -> ";
			cout << "P" << sequence[i] + 1;
		}
		cout << endl;
		show_available();
		show_sequence();
		result = true;
		return;
	}
	for (int i = 0; i < cnt_process; ++i)
	{
		if (!finished[i] && check(i))
		{
			sequence[cnt] = i;
			nextWork(i);
			dfs(cnt + 1);
			prevWork(i);
		}
	}
}

//bool check_finished(process &tmp)
//{
//	bool flag = true;
//	for (int j = 0; j < total_resources; j++)
//	{
//		if (tmp.resources_need[j])
//		{
//			return false;
//		}
//	}
//	return true;
//}

/*********************************************************
* 功能描述：安全性检查 
* 输入参数：无
* 输出参数：无 
* 返回值：无 
* 其它说明：无 
************************************************************/
void getResult()
{
	for (int i = 0; i < total_resources; ++i)
	{
		work[i] = resources_available[i];
	}
	for (int i = 0; i < cnt_process; ++i)
	{
		//		finished[i] = p[i].finished;
		finished[i] = false;
		sequence[i] = -1;
	}
	result = false;
	dfs(0);
}

/*********************************************************
* 功能描述：主函数 
* 输入参数：无
* 输出参数：无 
* 返回值：无 
* 其它说明：无 
************************************************************/
int main()
{
	cout << "资源种类默认设置为3" << endl;
	cout << "请输入进程个数：";
	cin >> cnt_process;
	cout << "请依次输入各进程的最大需求 MAX 和已分配资源 Allocation" << endl;
	for (int i = 0; i < cnt_process; i++)
	{
		process temp{};
		cout << "MAX of process" << i << ":" << endl;
		for (int &j : temp.resources_max)
		{
			cin >> j;
		}
		cout << "Allocation of process" << i << ":" << endl;
		for (int j = 0; j < total_resources; j++)
		{
			cin >> temp.resources_allocation[j];
			temp.resources_need[j] = temp.resources_max[j] - temp.resources_allocation[j];
		}
		//		temp.finished = check_finished(temp);
		temp.finished = false;
		p.push_back(temp);
	}
	cout << "Available:" << endl;
	for (int &i : resources_available)
	{
		cin >> i;
	}

	cout << endl
		 << "-----------------------------------------------" << endl
		 << endl;

	getResult();
	if (!result)
	{
		cout << "Deadlock!" << endl;
		return 0;
	}
	cout << "T" << State << " is safe." << endl
		 << endl;

	while (true)
	{
		int mark;
		cout << endl
			 << "1.继续申请资源" << endl
			 << "0.退出" << endl;
		cin >> mark;
		if (mark == 0)
			break;

		int process_num;
		cout << "选择进程 process(1-" << cnt_process << "): ";
		cin >> process_num;
		process_num--;

		cout << "输入请求向量 Request[1..." << total_resources << "]: ";
		for (int i = 0; i < total_resources; i++)
		{
			cin >> request[i];
		}

		bool flag = true;
		for (int i = 0; i < total_resources; i++)
		{
			if (request[i] > p[process_num].resources_need[i] || request[i] > resources_available[i])
			{
				flag = false;
				break;
			}
		}
		if (!flag)
		{
			cout << "请求向量不合法，请重新选择" << endl;
			continue;
		}

		for (int i = 0; i < total_resources; i++)
		{
			p[process_num].resources_allocation[i] += request[i];
			p[process_num].resources_need[i] -= request[i];
			resources_available[i] -= request[i];
		}

		getResult();
		if (!result)
		{
			cout << "T" << State + 1 << " is Deadlock!" << endl;
			return 0;
		}
		State++;
		cout << "T" << State << " is safe." << endl
			 << endl;
	}

	return 0;
}

/*
4
3 2 2
1 0 0
6 1 3
5 1 1
3 1 4
2 1 1
4 2 2
0 0 2
1 1 2

2
1 0 1
3
0 0 1
*/
LZH0217
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
银行家算法（c语言）
01-18
操作系统课的实验（银行家算法）#include "malloc.h" 　　#include "stdio.h" 　　#include "stdlib.h" 　　#define alloclen sizeof(struct allocation) 　　#define maxlen sizeof(struct max) 　　#define avalen sizeof(struct available) 　　#define needlen sizeof(struct need) 　　#define finilen sizeof(struct finish) 　　#define pathlen sizeof(struct path) 　　struct allocation 　　{ 　　int value; 　　struct allocation *next; 　　}; 　　struct max 　　{ 　　int value; 　　struct max *next; 　　}; 　　struct available /*可用资源数*/ 　　{ 　　int value; 　　struct available *next; 　　}; 　　struct need /*需求资源数*/ 　　{ 　　int value; 　　struct need *next; 　　}; 　　struct path 　　{ 　　int value; 　　struct path *next; 　　}; 　　struct finish 　　{ 　　int stat; 　　struct finish *next; 　　}; 　　int main() 　　{ 　　int row,colum,status=0,i,j,t,temp,processtest; 　　struct allocation *allochead,*alloc1,*alloc2,*alloctemp; 　　struct max *maxhead,*maxium1,*maxium2,*maxtemp; 　　struct available *avahead,*available1,*available2,*workhead,*work1,*work2,*worktemp,*worktemp1; 　　struct need *needhead,*need1,*need2,*needtemp; 　　struct finish *finihead,*finish1,*finish2,*finishtemp; 　　struct path *pathhead,*path1,*path2; 　　printf("\n请输入系统资源的种类数:"); 　　scanf("%d",&colum); 　　printf("请输入现时内存中的进程数:"); 　　scanf("%d",&row); 　　printf("请输入已分配资源矩阵:\n"); 　　for(i=0;i<row;i++) 　　{ 　　for (j=0;jnext=alloc2->next=NULL; 　　scanf("%d",&allochead->value); 　　status++; 　　} 　　else 　　{ 　　alloc2=(struct allocation *)malloc(alloclen); 　　scanf("%d,%d",&alloc2->value); 　　if(status==1) 　　{ 　　allochead->next=alloc2; 　　status++; 　　} 　　alloc1->next=alloc2; 　　alloc1=alloc2; 　　} 　　} 　　} 　　alloc2->next=NULL; 　　status=0; 　　printf("请输入最大需求矩阵:\n"); 　　for(i=0;i<row;i++) 　　{ 　　for (j=0;jnext=maxium2->next=NULL; 　　scanf("%d",&maxium1->value); 　　status++; 　　} 　　else 　　{ 　　maxium2=(struct max *)malloc(maxlen); 　　scanf("%d,%d",&maxium2->value); 　　if(status==1) 　　{ 　　maxhead->next=maxium2; 　　status++; 　　} 　　maxium1->next=maxium2; 　　maxium1=maxium2; 　　} 　　} 　　} 　　maxium2->next=NULL; 　　status=0; 　　printf("请输入现时系统剩余的资源矩阵:\n"); 　　for (j=0;jnext=available2->next=NULL; 　　work1->next=work2->next=NULL; 　　scanf("%d",&available1->value); 　　work1->value=available1->value; 　　status++; 　　} 　　else 　　{ 　　available2=(struct available*)malloc(avalen); 　　work2=(struct available*)malloc(avalen); 　　scanf("%d,%d",&available2->value); 　　work2->value=available2->value; 　　if(status==1) 　　{ 　　avahead->next=available2; 　　workhead->next=work2; 　　status++; 　　} 　　available1->next=available2; 　　available1=available2; 　　work1->next=work2; 　　work1=work2; 　　} 　　} 　　available2->next=NULL; 　　work2->next=NULL; 　　status=0; 　　alloctemp=allochead; 　　maxtemp=maxhead; 　　for(i=0;i<row;i++) 　　for (j=0;jnext=need2->next=NULL; 　　need1->value=maxtemp->value-alloctemp->value; 　　status++; 　　} 　　else 　　{ 　　need2=(struct need *)malloc(needlen); 　　need2->value=(maxtemp->value)-(alloctemp->value); 　　if(status==1) 　　{ 　　needhead->next=need2; 　　status++; 　　} 　　need1->next=need2; 　　need1=need2; 　　} 　　maxtemp=maxtemp->next; 　　alloctemp=alloctemp->next; 　　} 　　need2->next=NULL; 　　status=0; 　　for(i=0;inext=finish2->next=NULL; 　　finish1->stat=0; 　　status++; 　　} 　　else 　　{ 　　finish2=(struct finish*)malloc(finilen); 　　finish2->stat=0; 　　if(status==1) 　　{ 　　finihead->next=finish2; 　　status++; 　　} 　　finish1->next=finish2; 　　finish1=finish2; 　　} 　　} 　　finish2->next=NULL; /*Initialization compleated*/ 　　status=0; 　　processtest=0; 　　for(temp=0;temp<row;temp++) 　　{ 　　alloctemp=allochead; 　　needtemp=needhead; 　　finishtemp=finihead; 　　worktemp=workhead; 　　for(i=0;istat==0) 　　{ 　　for(j=0;jnext,worktemp=worktemp->next) 　　if(needtemp->valuevalue) 　　processtest++; 　　if(processtest==colum) 　　{ 　　for(j=0;jvalue+=alloctemp->value; 　　worktemp1=worktemp1->next; 　　alloctemp=alloctemp->next; 　　} 　　if(status==0) 　　{ 　　pathhead=path1=path2=(struct path*)malloc(pathlen); 　　path1->next=path2->next=NULL; 　　path1->value=i; 　　status++; 　　} 　　else 　　{ 　　path2=(struct path*)malloc(pathlen); 　　path2->value=i; 　　if(status==1) 　　{ 　　pathhead->next=path2; 　　status++; 　　} 　　path1->next=path2; 　　path1=path2; 　　} 　　finishtemp->stat=1; 　　} 　　else 　　{ 　　for(t=0;tnext; 　　finishtemp->stat=0; 　　} 　　} 　　else 　　for(t=0;tnext; 　　alloctemp=alloctemp->next; 　　} 　　processtest=0; 　　worktemp=workhead; 　　finishtemp=finishtemp->next; 　　} 　　} 　　path2->next=NULL; 　　finishtemp=finihead; 　　for(temp=0;tempstat==0) 　　{ 　　printf("\n系统处于非安全状态!\n"); 　　exit(0); 　　} 　　finishtemp=finishtemp->next; 　　} 　　printf("\n系统处于安全状态.\n"); 　　printf("\n安全序列为: \n"); 　　do 　　{ 　　printf("p%d ",pathhead->value); 　　} 　　while(pathhead=pathhead->next); 　　printf("\n"); 　　return 0; 　　} #include "string.h" #include #include #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 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() { int i=0,j=0; char flag='Y'; void showdata(); void changdata(int); void rstordata(int); int chkerr(int); showdata(); while(flag=='Y'||flag=='y') { i=-1; while(i=M) { printf("请输入需申请资源的进程号（从0到"); printf("%d",M-1); printf("，否则重输入!）:"); scanf("%d",&i); if(i=M)printf("输入的进程号不存在，重新输入!\n"); } printf("请输入进程"); printf("%d",i); printf("申请的资源数\n"); for (j=0;jNEED[i][j]) { printf("进程"); printf("%d",i); printf("申请的资源数大于进程"); printf("%d",i); printf("还需要"); printf("%d",j); printf("类资源的资源量!申请不合理，出错!请重新选择!\n"); /*printf("申请不合理，出错!请重新选择!\n");*/ flag='N'; break; } else { if(Request[j]>AVAILABLE[j]) { printf("进程"); printf("%d",i); printf("申请的资源数大于系统可用"); printf("%d",j); printf("类资源的资源量!申请不合理，出错!请重新选择!\n"); /*printf("申请不合理，出错!请重新选择!\n");*/ flag='N'; break; } } } if(flag=='Y'||flag=='y') { changdata(i); if(chkerr(i)) { rstordata(i); showdata(); } else showdata(); } else showdata(); printf("\n"); printf("是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: "); scanf("%c",&flag); } } void showdata() { int i,j; printf("系统可用的资源数为:\n"); printf(" "); for (j=0;j<N;j++){ printf(" 资源"); printf("%d",j); printf(":"); printf("%d",AVAILABLE[j]); /*printf("\n");*/ /* cout<<endl; // cout<<"各进程资源的最大需求量:"<<endl<<endl; // for (i=0;i<M;i++) // { // cout<<"进程"<<i<<":"; // for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<MAX[i][j]; // cout<<endl; */ } printf("\n"); printf("各进程还需要的资源量:\n"); for (i=0;i<M;i++) { printf(" 进程"); printf("%d",i); printf(":"); for (j=0;j<N;j++){ printf("资源"); printf("%d",j); printf(":"); printf("%d",NEED[i][j]); /*printf("\n");*/ } printf("\n"); } printf("各进程已经得到的资源量: \n"); for (i=0;i<M;i++) { printf(" 进程"); printf("%d",i); /*printf(":\n");*/ for (j=0;j<N;j++){ printf("资源"); printf("%d",j); printf(":"); 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 s) { int WORK,FINISH[M],temp[M]; 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; while(i<M) { if (FINISH[i]==FALSE&&NEED[i][j]<=WORK) { WORK=WORK+ALLOCATION[i][j]; FINISH[i]=TRUE; temp[k]=i; k++; i=0; } else { i++; } } for(i=0;i<M;i++) if(FINISH[i]==FALSE) { printf("\n"); printf("系统不安全!!! 本次资源申请不成功!!!\n"); printf("\n"); return 1; } } printf("\n"); printf("经安全性检查，系统安全，本次分配成功。\n"); printf("\n"); printf(" 本次安全序列："); for(i=0;i"); } printf("\n"); return 0; }
银行家算法 c语言
04-16
已知进程{P0,P1,P2,P3,P4}，有三类系统资源A、B、C的数量分别为10、5、7，在T0时刻的资源分配情况如下图所示： （1）若进程P1请求资源，发出请求向量Request1（1，0，2），编写程序用银行家算法判断系统能否将资源分配给它； （2）若进程P2提出请求Request(0，1，0)，用银行家算法程序验证系统能否将资源分配给它。
银行家算法——C语言（11计科1班-孙鹏启——修正）
张同光 (Tongguang Zhang)：Hello everyone !
02-01 903
#define M 50 #include "stdio.h" int max[M][M], allocation[M][M], need[M][M], available[M];    /*定义全局变量 */ int i, j, n, m, r, t; void main() {     void check();     void print();     int p, q;
银行家算法——输出所有安全序列
入门C语言——杭电oj2016
11-09 6218
银行家算法——输出所有安全序列 银行家算法的具体思路可见我的另一篇文章 点击了解 思路:递归从N个进程里选一个满足条件的进程作为一个安全序列的第一个元素，之后再各自从剩下的进程中选择满足条件的作为第二个元素…… 问题:由于确定每一个安全序列、以及确定安全序列的每一个元素的过程中Finish[i]和Work[j]都在变化，所以需要一个撤回操作的步骤(回溯） 和深度优先搜索类似 代码如下 #inc...
银行家算法C语言
入门C语言——杭电oj2016
10-25 3711
操作系统实验——银行家算法 相关数据结构: 可利用资源向量Available:这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。如果Available［j］=K，则表示系统中现有Rj类资源K个。 最大需求矩阵Max: 这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最...
操作系统银行家算法
11-28
操作系统中的“银行家算法”是一种资源分配策略，用于预防死锁的发生。在多任务环境下，系统中的资源（如CPU时间、内存、磁盘空间等）是有限的，多个进程可能会竞争这些资源，如果分配不当，可能导致无法恢复的僵局...
操作系统 银行家算法.pdf
01-20
银行家算法是一种用来避免操作系统死锁出现的有效算法，银行家算法，可以了解死锁的概念。死锁：是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都...
操作系统银行家算法避免死锁
06-17
银行家算法避免死锁 VM软件 Linux系统 C语言 成功编译 成功运行 内附完整课设报告，代码，运行cpp 附有哲学家进餐简略一题 原课设要求：死锁避免 （1）请设计一个程序演示死锁避免算法（银行家算法）。 （2）要求该...
操作系统银行家算法.doc
11-13
操作系统银行家算法 操作系统银行家算法是一种资源分配算法，用于解决操作系统中的资源竞争问题。该算法通过检查系统的安全性和稳定性，确保系统不会陷入死锁或饥饿状态。 银行家算法的原理 银行家算法的核心思想...
操作系统银行家算法学习
最新发布
01-17
操作系统银行家算法学习 在操作系统中，银行家算法是一种资源分配算法，用于避免系统中的死锁和饥饿现象。该算法通过检查系统中的资源情况和进程的需求来确定是否可以满足进程的请求。 在银行家算法中，系统的资源...
银行家算法（c语言代码）
12-29
这是我参考了很多的同类代码后，自己写的一个实现银行家算法以及随机分配算法的c语言代码。这个代码符合操作系统课程设计有关银行家算法的实现。这是我的老师验收之后，并且修改过后的代码。欢迎大家下载。这个代码简单易懂，不复杂，适合大多数人使用。代码内注释较详细，更加方便读懂程序。
C语言银行家算法
05-10
操作系统银行家算法C语言代码，银行家算法的所有代码
银行家算法C语言实现
12-07
银行家算法C语言实现，避免死锁的经典算法的C语言实现
系统软件综合训练——银行家算法
04-21
n个用户，m个资源。用银行家算法求出所有安全序列（采用深度优先算法）。包含概述、总体设计、详细设计（包含各模块流程图）、模块分析、代码、运行结果、心得。
银行家算法 c语言
mdjsmg的博客
04-16 3075
操作系统学习之银行家算法，c语言代码实现
银行家算法C语言版
winneryy的博客
12-09 3497
#include <stdio.h> #include <stdlib.h> #include <conio.h> # define m 50 # define true 1 # define false 0 int no1; //进程数 int no2; //资源数 int r; int allocation[m][m],need[m][m],available[m],max[m][m]; char name1[m],name2[m]; .
c语言——银行家算法
weixin_44581918的博客
11-25 310
学习完操作系统的课程后，我迫不及待地进行了银行家算法的编写。其中银行家算法的编写只需3步； 话不多说，直接进入代码分析。 完整代码如下： #include<iostream> #include<assert.h> using namespace std; #define num_of_resource 3 #define num_of_binary 5 clas...
银行家算法(C语言实现)
weixin_45939614的博客
11-17 1012
添加链接描述 转载地址~~ #include<stdio.h> int Max[5][3] = {0,1,2,4,2,2,3,0,3,3,1,1,0,0,4}; //五个进程对各种资源的最大需求 int Allocation[5][3] = {0,1,0,2,0,0,3,0,3,2,1,1,0,0,2}; //五个进程已分配的各种资源数目 int Need[5][3] = {0,0,2,2,2,2,0,0,0,1,0,0,0,0,2}; //五个进程任需要各种资
银行家算法（C 语言实现）
Touch的博客
05-16 1123
这个程序局限性很大，只是为了熟悉一下银行家算法而已，所以随便写写罗。。。   #include&lt;stdio.h&gt; #define PROCESS_AMOUNT 5 //进程数量 #define RESOURCE_AMOUNT 3 //资源数量 //系统提供的各类资源的最大量 int Resoure_Max[3]={10,5,7}; //...
操作系统 银行家算法
11-22
银行家算法是一种用于避免死锁的资源分配算法。它通过判断系统是否处于安全状态来决定是否分配资源给进程。在银行家算法中，系统维护了以下几个数据结构： 1. Available：表示系统中每种资源的可用数量。 2. Max：表示每个进程对每种资源的最大需求量。 3. Allocation：表示每个进程已分配的资源数量。 4. Need：表示每个进程还需要的资源数量。 银行家算法的基本思想是，当一个进程请求资源时，系统会先检查该请求是否满足以下条件： 1. Request <= Need：进程请求的资源数量不能超过其还需要的资源数量。 2. Request <= Available：进程请求的资源数量不能超过系统中可用的资源数量。 如果满足以上两个条件，则系统会模拟分配资源给进程，并更新Available、Allocation和Need的值。然后，系统会检查分配资源后的状态是否安全，即是否存在一种资源分配顺序，使得所有进程都能完成执行。如果存在安全序列，则系统会真正分配资源给进程；否则，系统会拒绝分配资源，以避免死锁。 以下是一个简单的银行家算法的示例代码： ```python def is_safe_state(available, max_demand, allocation): num_processes = len(max_demand) num_resources = len(available) work = available[:] finish = [False] * num_processes while True: found = False for i in range(num_processes): if not finish[i] and all(need <= work for need, work in zip(max_demand[i], work)): work = [work[j] + allocation[i][j] for j in range(num_resources)] finish[i] = True found = True if not found: break return all(finish) available = [3, 3, 2] max_demand = [[7, 5, 3], [3, 2, 2], [9, 0, 2], [2, 2, 2], [4, 3, 3]] allocation = [[0, 1, 0], [2, 0, 0], [3, 0, 2], [2, 1, 1], [0, 0, 2]] if is_safe_state(available, max_demand, allocation): print("System is in a safe state.") else: print("System is in an unsafe state.") ``` 该示例中，available表示系统中每种资源的可用数量，max_demand表示每个进程对每种资源的最大需求量，allocation表示每个进程已分配的资源数量。is_safe_state函数用于判断系统是否处于安全状态。如果系统处于安全状态，则输出"System is in a safe state."；否则，输出"System is in an unsafe state."。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值