银行家算法的实现

最新推荐文章于 2024-04-28 00:34:31 发布
最新推荐文章于 2024-04-28 00:34:31 发布
阅读量816 收藏
点赞数
文章标签： 算法 list allocation null c struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/handsomesunshineboy/article/details/6619103
版权
  
//zhu_jie_mian.cpp
#include<iostream.h>
#include"bank.h"
void zhu_jie_mian(list * &L,int &n)
{
	cout<<"         ++++++++++++++++++++进程资源调度管理+++++++++++++++++++++++"<<endl;
	cout<<"         +               1.显示当前进程与资源状态                  +"<<endl;
	cout<<"         +                       2.增加进程                        +"<<endl;
	cout<<"         +                       3.死锁检测                        +"<<endl;
	cout<<"         +                       4.申请资源                        +"<<endl;
	cout<<"         +                       5.撤销资源                        +"<<endl;
	cout<<"         +                       6.结束进程                        +"<<endl;
	cout<<"         +                       7.退出程序                        +"<<endl;
	cout<<"         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
	int choice;
	cin>>choice;
	switch(choice)
	{
		case 1:xianshi(L,n);break;
		case 2:zengjia(L,n);break;
		case 3:jiance(L,n);break;
		case 4:shenqing(L,n);break;
		case 5:chexiao(L,n);break;
		case 6:jieshu(L,n);break;
		case 7:break;
	}
}

//zengjia.cpp
#include<iostream.h>
#include<malloc.h>
#include"bank.h"
void zengjia(list * &L,int &n)
{
	list *t,*s;
	int choice;
	s=L;
	while(s->next!=NULL)
		s=s->next;
	t=(list *)malloc(sizeof(list));
	cout<<"请输入此进程的号码:"<<endl;
	cin>>t->haoma;
	cout<<"请分别输入此进程申请的A、B、C资源数:"<<endl;
	cin>>t->data.claim[0]>>t->data.claim[1]>>t->data.claim[2];
	cout<<"请分别输入此进程已占有的A、B、C资源数:"<<endl;
	cin>>t->data.allocation[0]>>t->data.allocation[1]>>t->data.allocation[2];
	cout<<"请分别输入此进程仍需要的A、B、C资源是:"<<endl;
	cin>>t->data.need[0]>>t->data.need[1]>>t->data.need[2];
	t->state=0;
	n++;
	t->next=s->next;
	s->next=t;
	cout<<"         ======================1.继续增加进程======================="<<endl;
	cout<<"         =======================2.返回主界面========================"<<endl;
	cin>>choice;
	switch(choice)
	{
		case 1:zengjia(L,n);break;
		case 2:zhu_jie_mian(L,n);break;
	}
}

//xianshi.cpp
#include<iostream.h>
#include"bank.h"
void xianshi(list * &L,int &n)
{
	list *t;
	int choice;
	int A_temp=0,B_temp=0,C_temp=0;
	t=L->next;
	cout<<"                 Claim      Allocation     Need       Available"<<endl;
	cout<<"         号码   A  B  C      A  B  C      A  B  C      A  B  C"<<endl;
	while(t!=NULL)
	{
		cout<<"           "<<t->haoma<<"    "<<t->data.claim[0]<<"  "<<t->data.claim[1]<<"  "<<t->data.claim[2]<<"      "<<t->data.allocation[0]<<"  "<<t->data.allocation[1]<<"  "<<t->data.allocation[2]<<"      "<<t->data.need[0]<<"  "<<t->data.need[1]<<"  "<<t->data.need[2];
		A_temp+=t->data.allocation[0];
		B_temp+=t->data.allocation[1];
		C_temp+=t->data.allocation[2];
		if(t->next==NULL)
			cout<<"      "<<A_total-A_temp<<"  "<<B_total-B_temp<<"  "<<C_total-C_temp<<endl;
		else
			cout<<endl;
		t=t->next;
	}
	cout<<"         =======================1.返回主界面========================"<<endl;
	cout<<"         ========================2.结束程序========================="<<endl;
	cin>>choice;
	switch(choice)
	{
		case 1:zhu_jie_mian(L,n);break;
		case 2:break;
	}
}

//shenqing.cpp
#include"bank.h"
#include<iostream.h>
void shenqing(list * &L,int &n)
{
	int choice,i,request[3],A_temp=0,B_temp=0,C_temp=0,available[3];
	list *t;
	t=L->next;
	cout<<"请输入想要申请资源的进程号:"<<endl;
	cin>>i;
	while(t!=NULL)
	{
		A_temp+=t->data.allocation[0];
		B_temp+=t->data.allocation[1];
		C_temp+=t->data.allocation[2];
		t=t->next;
	}
	available[0]=A_total-A_temp;
	available[1]=B_total-B_temp;
	available[2]=C_total-C_temp;
	t=L->next;
	while(t->haoma!=i)
		t=t->next;
	cout<<"请分别输入此进程申请A、B、C资源的资源数（提示：必须小于可用资源数和最大需求数，否则系统会重新输入！）:"<<endl;
	cin>>request[0]>>request[1]>>request[2];
	while(request[0]>available[0]||request[1]>available[1]||request[2]>available[2]||request[0]>t->data.need[0]||request[1]>t->data.need[1]||request[2]>t->data.need[2])
	{
		cout<<"您输入的数据不符合要求，请重新输入:"<<endl;
		cin>>request[0]>>request[1]>>request[2];
	}
	t=L->next;
	while(t!=NULL)
	{
		if(t->haoma==i)
		{
			t->data.allocation[0]+=request[0];
			t->data.allocation[1]+=request[1];
			t->data.allocation[2]+=request[2];
			t->data.need[0]-=request[0];
			t->data.need[1]-=request[1];
			t->data.need[2]-=request[2];
		}
		t=t->next;
	}
	cout<<"         =======================1.返回主界面========================"<<endl;
	cout<<"         ========================2.检测死锁========================="<<endl;
	cin>>choice;
	switch(choice)
	{
		case 1:zhu_jie_mian(L,n);break;
		case 2:jiance(L,n);break;
	}
}

//jieshu.cpp
#include"bank.h"
#include<iostream.h>
#include<malloc.h>
void jieshu(list * &L,int &n)
{
	int i,choice;
	list *t,*s;
	t=L;
	s=t->next;
	cout<<"请输入您想结束的进程的进程号:"<<endl;
	cin>>i;
	while(s!=NULL)
	{
		if(s->haoma==i)
		{
			t->next=s->next;
			free(s);
			s=t->next;
			n--;
		}
		else
		{
			t=t->next;
			s=s->next;
		}
	}
	cout<<"         ======================1.继续结束进程======================="<<endl;
	cout<<"         =======================2.返回主界面========================"<<endl;
	cin>>choice;
	switch(choice)
	{
		case 1:jieshu(L,n);break;
		case 2:zhu_jie_mian(L,n);break;
	}
}

//jiance.cpp
#include"bank.h"
#include<iostream.h>
void jiance(list * &L,int &n)
{
	int i,A_temp=0,B_temp=0,C_temp=0,flag[100],j=0,available[3],choice;
	list *t;
	t=L->next;
	while(t!=NULL)
	{
		A_temp+=t->data.allocation[0];
		B_temp+=t->data.allocation[1];
		C_temp+=t->data.allocation[2];
		t->state=0;
		t=t->next;
	}
	available[0]=A_total-A_temp;
	available[1]=B_total-B_temp;
	available[2]=C_total-C_temp;
	for(i=0;i<n;i++)
	{
		for(t=L->next;t!=NULL;t=t->next)
		{
			if(t->state==1)
				continue;
			else if((t->data.need[0]<=available[0])&&(t->data.need[1]<=available[1])&&(t->data.need[2]<=available[2]))
			{
				available[0]+=t->data.allocation[0];
				available[1]+=t->data.allocation[1];
				available[2]+=t->data.allocation[2];
				flag[j++]=t->haoma;
				t->state=1;
			}
		}
	}
	if((available[0]==A_total)&&(available[1]==B_total)&&(available[2]==C_total))
	{
		cout<<"         此状态很安全，无死锁，安全序列为:";
		for(i=0;i<n;i++)
		{
			cout<<flag[i]<<"->";
		}
		cout<<endl;
	}
	else
		cout<<"         此状态存在死锁，可以采取结束进程来结束死锁状态。"<<endl;
	cout<<"         =======================1.返回主界面========================"<<endl;
	cout<<"         ========================2.结束程序========================="<<endl;
	cin>>choice;
	switch(choice)
	{
		case 1:zhu_jie_mian(L,n);break;
		case 2:break;
	}
}



//chexiao.cpp
#include"bank.h"
#include<iostream.h>
void chexiao(list * &L,int &n)
{
	int choice,i,request[3];
	list *t;
	t=L->next;
	cout<<"请输入想要撤销资源的进程号:"<<endl;
	cin>>i;
	cout<<"请分别输入此进程撤销A、B、C资源的资源数（提示：必须小于已占有资源数，否则系统会重新输入！）:"<<endl;
	cin>>request[0]>>request[1]>>request[2];
	while(t->haoma!=i)
		t=t->next;
	while(request[0]>t->data.allocation[0]||request[1]>t->data.allocation[1]||request[2]>t->data.allocation[2])
	{
		cout<<"您输入的数据不符合要求，请重新输入:"<<endl;
		cin>>request[0]>>request[1]>>request[2];
	}
	t=L->next;
	while(t!=NULL)
	{
		if(t->haoma==i)
		{
			t->data.allocation[0]-=request[0];
			t->data.allocation[1]-=request[1];
			t->data.allocation[2]-=request[2];
		}
		t=t->next;
	}
	cout<<"         =======================1.返回主界面========================"<<endl;
	cout<<"         ========================2.检测死锁========================="<<endl;
	cin>>choice;
	switch(choice)
	{
		case 1:zhu_jie_mian(L,n);break;
		case 2:jiance(L,n);break;
	}
}

//bank.cpp
#include"bank.h"
#include<iostream.h>
#include<malloc.h>
int main()
{	
	list *L;
	int n=0;
	L=(list *)malloc(sizeof(list));
	L->haoma=NULL;
	L->next=NULL;
	zhu_jie_mian(L,n);
	return 0;
}

//bank.h
#define A_total 10
#define B_total 5
#define C_total 7
typedef struct 
{
	int claim[3];
	int allocation[3];
	int need[3];
}jincheng;
typedef struct node
{
	int haoma;
	jincheng data;
	int state;
	struct node *next;
}list;
void zhu_jie_mian(list *&,int &);
void xianshi(list * &,int &);
void zengjia(list * &,int &);
void jiance(list * &,int &);
void shenqing(list * &,int &);
void chexiao(list * &,int &);
void jieshu(list * &,int &);

IiI1-1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
实验三 银行家算法的实现
weixin_51163121的博客
06-06 1001
实验三 银行家算法的实现一、预备知识1．死锁的相关知识。2．银行家算法。3．系统安全性检查。二、目的1．加深了解有关资源申请、避免死锁等概念。2．体会和了解死锁和避免死锁的具体实施方法。三、要求1．理解死锁的概念以及产生死锁的原因。2．了解检测状态安全性的方法。3．掌握利用银行家算法避免死锁的做法。四、实验内容银行家算法是避免死锁的一种重要方法，本实验要求编写和调试一个简单的银行家算法程序。1．设计进程对各类资源最大申请表示及初值的确定。2．设定系统提供资源的初始状况。3．设定每次某个进程对各类资源的申请
银行家算法实现
06-24
本代码为操作系统的银行家算法，分为两部分，一部分为初始状态检验，一部分为申请资源时的检验
银行家算法实现（代码全面解析）
07-16
一．算法分析: (一)数据结构: 1.可利用资源向量Available 2.最大需求矩阵Max 3.分配矩阵Allocation 4.需求矩阵Need （二）功能介绍: 模拟实现Dijkstra的银行家算法以避免死锁的出现.分两部分组成: 第一部分:银行家算法(扫描) 1．如果Request<=Need,则转向2;否则,出错 2．如果Request<=Available,则转向3,否则等待 3．系统试探分配请求的资源给进程 4．系统执行安全性算法 第二部分:安全性算法 1.设置两个向量 (1).工作向量:Work=Available(表示系统可提供给进程继续运行所需要的各类资源数目 (2).Finish:表示系统是否有足够资源分配给进程(True:有;False:没有).初始化为False 2.若Finish[i]=False&&Need;<=Work,则执行3;否则执行4(I为资源类别) 3.进程P获得第i类资源,则顺利执行直至完成!并释放资源: Work=Work+Allocation;Finish[i]=true;转2 4.若所有进程的Finish[i]=true,则表示系统安全;否则,不安全!
【操作系统】银行家算法的实现
只识闲人不识君博客
06-25 2876
银行家算法对应实验一、银行家算法概念二、实验环境三、实验题目四、实验步骤五、实验代码六、实验结果 一、银行家算法概念 银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。 安全序列：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。 不安全状序列：不存在一个安全序列。不安
ese.rar_银行家算法实现
09-21
本程序模拟银行家算法，用银行家算法实现资源分配。
银行家算法实现（操作系统实验）
m0_53112875的博客
05-23 1903
#include <string.h> #include<iostream.h> #define FALSE 0 #define TRUE 1 #define W 10 #define R 20 int M; int N; int ALL_RESOURCE[W]; int AVAILABLE[R]; int MAX[W][R]; int ALLOCATION[W][R]; //分配矩阵 int NEED[W][R]; //需求矩阵 int Request[R]; .
计算机操作系统_银行家算法
热门推荐
魏宇轩
12-05 21万+
银行家算法
银行家算法( 详解 )
Bit_Dong的博客
07-22 4万+
银行家算法是操作系统的经典算法之一，用于避免死锁情况的出现。它最初是为银行设计的（因此得名），通过判断借贷是否安全，然后决定借不借。在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。用在操作系统中，银行家、出借资金、客户，就分别对应操作系统、资源、申请资源的进程。...
C语言实现银行家算法
03-15
使用C语言实现银行家算法，其中包括安全性算法和资源分配算法
银行家算法（C++实现）
05-15
本程序是按操作系统的书做的，程序的可读性很强，欢迎大家下载！
银行家算法（VS编程实现）
07-17
#define  n  5  //进程个数 #define  m  3  //资源种类 int   Available[m],Alloc[n][m],Need[n][m]; main() {    int request[m];    input( );    while (1)    {       read_req( );        if  (请求结束)   break;   (1) if (!(requesti<=Needi))   表示非法请求；   (2) if (!(requesti<=Availablei)) 则Pi阻塞；  (3)试探性分配 Available=Available - Requesti;        Alloci=Alloci+Requesti;        Needi=Needi-Requesti;   (4)若新状态安全，则实际分配资源给Pi,否则取消试探性分配。   } } 安全状态判别算法： (1)设置Finish=(false,...,false) work=Available (2)循环查找满足下列条件的进程pi    //最多循环n次         Finish[i]=false且Needi<=work (3)若找到则 Finish[i]=true;work=work+Alloci; 转(2) (4)若Finish=(true,...,true) 则安全，否则不安全。 测试数据：m=3:种类型的资源（A,B,C,） 进程个数n=5 Available=(2,3,3);
银行家算法C语言实现
12-07
银行家算法C语言实现，避免死锁的经典算法的C语言实现
银行家算法java实现
01-02
资源有三种，线程数为5，适合各种课程设计作业和参考学习
银行家算法java实现带UI界面（修正版）
06-19
银行家算法java实现带UI界面（修正版：修改了由yu114提出的BankerMainUI.java与AddProcessDialog.java文件相同的问题） 以后大家发现类似问题的话，请大家知会一声，希望我们共同成长。
基于C++的银行家算法模拟实现
05-04
设计要求 使用C++设计一个n 个并发进程共享m 个系统资源的系统。其中进程可动态申请资源和释放资源，系统按各进程的申请动态的分配资源，要求采用银行家算法实现。 设计思想 本实验是基于Dijkstra的银行家算法的实现，该算法可用于在操作系统中避免死锁。 该算法的基本思想是：让用户输入进程数与资源类数，并输入每个进程对每类资源的最大需求量，已占用数，以及系统中当前每类资源的可用数。再选择一个进程让其申请资源。当进程动态地申请资源时，系统必须首先确定是否有足够的资源分配给该进程。若有，系统将进一步计算在将这些资源分配给进程后，是否会使系统进入不安全状态，如果不会，系统才能将资源分配给它，否则系统让进程等待。 设计流程 本算法分为三步：初始状态安全性检查→银行家算法模拟分配进程→安全性检查。
银行家算法（C实现）
07-18
银行家算法是一个避免死锁的著名算法，它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。
Codeforces Round 941 (Div. 2) （A~D）
最新发布
weixin_61825750的博客
04-28 701
然后考虑若此时存在两个堆，那么对于Alice而言，其操作可以使得小的那个堆只剩下1，下一步Bob必须选1，然后Alice就胜利了。相反，若小的那个堆一开始就是1，那么Alice就输了。接下来推广到若干堆的情况：对于任意一方而言，若最小堆不是1，那么便可以控制胜利，于是我们只需要枚举到最小堆不是1的情况即可，然后看是谁在操作就是谁赢。思路：若要使得所有方格同色，关键在于四个角上的颜色，若对角上的颜色一样就能直接将所有格子变为同色。思路：首先处理 < k 的部分，我们可以通过二进制的思想来构造整数，例如。
银行家算法实现资源分配
10-31
银行家算法实现资源分配的过程如下： 1. 当一个进程请求资源时，系统首先检查该请求是否合法，即该进程请求的资源数是否小于等于系统当前可用的资源数。 2. 如果该请求合法，则系统试图为该进程分配资源，并更新系统...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值