精华内容
下载资源
问答
  • 银行家算法C语言实现

    2014-12-07 19:57:23
    银行家算法C语言实现,避免死锁的经典算法的C语言实现
  • 银行家算法 C语言实现

    千次阅读 多人点赞 2019-05-05 22:46:18
    C语言实现银行家算法 这几天老师要求使用C语言实现银行家算法,数据可以自定义。想来想去还是照着书现成的数据来模拟一下。 教材使用的是西安电子科大出版社的《计算机操作系统》汤小丹 第四版。模拟数据使用的是P...

    C语言实现银行家算法

    这几天老师要求使用C语言实现银行家算法,数据可以自定义。想来想去还是照着书现成的数据来模拟一下。

    教材使用的是西安电子科大出版社的《计算机操作系统》汤小丹 第四版。模拟数据使用的是P121页第4题的数据。

    听到老师布置题目的第一时间我还是有点懵,看了下书更懵了,这条条框框的判断条件怎么这么多。。沉下心来慢慢看,其实还是挺简单的算法。

    /*Author:Cnkizy
    数据参考 P121 4.银行家算法之例
    */
    #include<stdio.h>
    #define Pcount 5 //5个进程
    #define Scount 3 //3类资源
    int Available[Scount];//可利用资源向量
    int Max[Pcount][Scount];//最大需求矩阵 可以通过Need+Allocation算出来
    int Allocation[Pcount][Scount];//分配矩阵
    int Need[Pcount][Scount];//需求矩阵
    //int SouresMax[Scount] = { 10,5,7 };//这里给ABC三类资源的数量为10,5,7
    /*资源分配表,必要的一些数据如下
    	Max		Allocation	Need	Available
    	P0		0 1 0		7 4 3	3 3 2
    	P1		2 0 0		1 2 2
    	P2		3 0 2		6 0 0
    	P3		2 1 1		0 1 1
    	P4		0 0 2		4 3 1
    */
    //初始化数据
    void InitializeData();
    //查看当前资源分配表
    void ShowData(int line);
    //计算最大需求数量
    void CalcMaxMatrix();
    //资源比较   a<=b 返回1     a>b 返回0
    int Equals(int a[Scount], int b[Scount]);
    //安全性算法,当前是否处于安全状态
    int CheckSafe();
    //检查标志所有都为True,是返回1 不是返回0
    int CheckFinish(int Finish[Scount]);
    //向量相加 a = a+b
    void Add(int* a, int b[Scount]);
    //向量相减 a = a-b
    void Minus(int* a, int b[Scount]);
    //进程资源请求 P:进程i,r申请资源数{1,1,1} 返回1成功 0失败
    int Request(int P, int Request[Scount]);
    //带命令提示符提示的请求
    void RequestShowMsg(int P, int R[Scount]);
    int main() {
    	//初始化银行家算法的数据,详见上表
    	InitializeData();
    	printf("=============初始数据如下=============\n");
    	ShowData(0);
    	//安全性检查
    	CheckSafe();
    
    	//进程P1 申请资源{1,0,2}
    	int apply[Scount] = { 1,0,2 };
    	RequestShowMsg(1, apply);
    
    	//进程P4 申请资源{1,0,2}
    	int apply2[Scount] = { 3,3,0 };
    	RequestShowMsg(4, apply2);
    
    	//进程P0 申请资源{0,2,0}
    	int apply3[Scount] = { 0,2,0 };
    	RequestShowMsg(0, apply3);
    
    	return 0;
    }
    //初始化数据,资源分配表
    void InitializeData() {
    
    	Allocation[0][0] = 0, Allocation[0][1] = 1, Allocation[0][2] = 0;
    	Allocation[1][0] = 2, Allocation[1][1] = 0, Allocation[1][2] = 0;
    	Allocation[2][0] = 3, Allocation[2][1] = 0, Allocation[2][2] = 2;
    	Allocation[3][0] = 2, Allocation[3][1] = 1, Allocation[3][2] = 1;
    	Allocation[4][0] = 0, Allocation[4][1] = 0, Allocation[4][2] = 2;
    
    	Need[0][0] = 7, Need[0][1] = 4, Need[0][2] = 3;
    	Need[1][0] = 1, Need[1][1] = 2, Need[1][2] = 2;
    	Need[2][0] = 6, Need[2][1] = 0, Need[2][2] = 0;
    	Need[3][0] = 0, Need[3][1] = 1, Need[3][2] = 1;
    	Need[4][0] = 4, Need[4][1] = 3, Need[4][2] = 1;
    
    	Available[0] = 3, Available[1] = 3, Available[2] = 2;
    
    	CalcMaxMatrix();
    }
    //进程资源请求 P:进程i,r申请资源数{1,1,1} 返回1成功 0失败
    int Request(int P,int Request[Scount]) {
    	printf("进程P%d申请资源%d %d %d:\n",P, Request[0], Request[1], Request[2]);
    	//步骤1 进行资源检查Request <= Need才能执行步骤2
    	if (!Equals(Request, Need[P])) {
    		printf("进程P%d,Request:%d %d %d > Need:%d %d %d 申请失败,所需资源数超过宣布最大值!\n", P, Request[0], Request[1], Request[2], Need[P][0], Need[P][1], Need[P][2]);
    		return 0;
    	}
    	//步骤2 进行资源检查Request <= Available才能执行步骤3
    	if (!Equals(Request, Available)) {
    		printf("进程P%d,Request:%d %d %d > Available:%d %d %d 申请失败,尚无足够资源,该进程需要等待!\n", P, Request[0], Request[1], Request[2], Available[0], Available[1], Available[2]);
    		return 0;
    	}
    	printf("进程P%d,Request:%d %d %d <= Need:%d %d %d\n", P, Request[0], Request[1], Request[2], Need[P][0], Need[P][1], Need[P][2]);
    	printf("进程P%d,Request:%d %d %d <= Available:%d %d %d \n", P, Request[0], Request[1], Request[2], Available[0], Available[1], Available[2]);
    	//步骤3 试分配资源给进程P
    	Minus(Available, Request);//Available -= Request
    	Add(Allocation[P],Request);//Allocation += Request
    	Minus(Need[P], Request);//Need -= Request
    	//步骤4 安全性检查
    	int Safestate = CheckSafe();
    	if (Safestate) {
    		return Safestate;//分配后处于安全状态 分配成功
    	}
    	//分配后处于不安全状态 分配失败,本次分配作废,回复原来的资源分配状态
    	Add(Available, Request);//Available += Request
    	Minus(Allocation[P], Request);//Allocation -= Request
    	Add(Need[P], Request);//Need += Request
    	return Safestate;
    }
    //带命令提示符提示的请求
    void RequestShowMsg(int P, int R[Scount]) {
    	//进程P 申请资源Request{1,0,2}
    	printf("\n模拟分配资源:P%d申请资源 %d %d %d\n======================\n",P, R[0], R[1], R[2]);
    	int State = Request(P, R);
    	if (State) {
    		printf("本次资源分配成功!\n");
    		ShowData(0);
    	}else {
    		printf("本次资源分配失败!进程P%d需要等待\n",P);
    	}
    }
    //安全性算法,当前是否处于安全状态
    int CheckSafe() {
    	printf("开始安全性检查:\n");
    	//步骤1 设置两个向量
    	int Finish[Pcount] = { 0 };//是否被处理过,初始值全为False,被检查过才置为True
    	int Work[Scount] = { 0 };//工作向量	
    	Add(Work, Available);//首先让Work = Available
    	//步骤2 从进程集合寻找符合下列条件的进程
    	//Finish[i] =  false;
    	//Need[i,j] <= Work[j];
    	for (int i = 0; i < Pcount; i++) {
    		if (Finish[i])continue;//已经标记为True就跳过
    		if (!Equals(Need[i], Work))continue;//Need[i,j] > Work[j] 就跳过。
    		//上述条件成立,执行步骤3
    		Add(Work, Allocation[i]);//Work += Allocation;
    		Finish[i] = 1;//Finish[i]=True;	
    		printf("P%d进程,Work=%d %d %d,Finish=true,安全状态\n", i, Work[0], Work[1], Work[2]);
    		i = -1;//返回步骤2
    	}
    	//步骤4 判断Finish
    	if (CheckFinish(Finish)) {
    		printf("安全状态检查完毕:【Finish全为true,系统处于安全状态】\n");
    		return 1;//全为True		
    	}
    	printf("安全状态检查完毕:【Finish存在False,系统处于不安全状态】\n");
    	return 0;//存在False
    }
    //检查标志所有都为True,是返回1 不是返回0
    int CheckFinish(int Finish[Pcount]) {
    	for (int i = 0; i < Pcount; i++) {
    		if (Finish[i] == 0) return 0;
    	}
    	return 1;
    }
    //查看当前资源分配表
    void ShowData(int line) {
    	printf("	Max	Alloca	Need	Available\n");
    	for (int i = 0; i < Pcount; i++) {
    		printf("p%d:\t", i);
    		for (int j = 0; j < Scount; j++) {
    			printf("%d ", Max[i][j]);
    		}
    		printf("\t");
    		for (int j = 0; j < Scount; j++) {
    			printf("%d ", Allocation[i][j]);
    		}
    		printf("\t");
    		for (int j = 0; j < Scount; j++) {
    			printf("%d ", Need[i][j]);
    		}
    
    		if (line == i) {
    			printf("\t");
    			for (int j = 0; j < Scount; j++) {
    				printf("%d ", Available[j]);
    			}
    		}
    
    		printf("\n");
    	}
    
    }
    //计算最大需求数量
    void CalcMaxMatrix() {
    	for (int i = 0; i < Pcount; i++) {
    		for (int j = 0; j < Scount; j++) {
    			Max[i][j] = Need[i][j] + Allocation[i][j];
    		}
    	}
    }
    //向量相加 a = a+b
    void Add(int* a, int b[Scount]) {
    	for (int i = 0; i < Scount; i++) {
    		a[i] = a[i] + b[i];
    	}
    }
    //向量相减 a = a-b
    void Minus(int* a, int b[Scount]) {
    	for (int i = 0; i < Scount; i++) {
    		a[i] = a[i] - b[i];
    	}
    }
    //资源比较   a<=b 返回1     a>b 返回0
    int Equals(int a[Scount], int b[Scount]) {
    	for (int i = 0; i < Scount; i++) {
    		if (a[i] > b[i]) return 0;
    	}
    	return 1;
    }

    偷懒for循环所以使用了C++编译器。

    展开全文
  • 银行家算法 C语言实现 带注释加粗样式**** 在这里插入代码片#include <stdio.h> #define M 100 #define N 50 ///定义M个进程,N类资源 void Init(); bool checkSecurity (int); void show(); int Bank(int); ...

    银行家算法 C语言实现 带注释加粗样式****

    在这里插入代码片#include <stdio.h>
    #define M 100
    #define N 50   ///定义M个进程,N类资源
    void Init();
    bool checkSecurity (int);
    void show();
    int Bank(int);
    int Available[M];       ///可利用资源数组
    int Max[N][M];   ///最大需求矩阵
    int Allocation[N][M];  ///分配矩阵
    int Need[N][M];        ///需求矩阵
    int Request[N][M];   /**M个进程还需要N类资源的资源量*/
    bool Finish[N];
    int p[N];
    int m,n;   ///M个进程,N类资源
    int main (void)
    {
    	int i;
    	int Flag0 = 0;
    	int Flag1 = 1;
    	printf("O(∩_∩)O 您好!欢迎使用本系统! O(∩_∩)O\n");
    	Init ();
    	while(1)
    	{
    
    	printf(" 1 --> /****************银行家算法***********/\n");
    	printf(" 2 --> /****************死锁检测*************/\n") ;
    	printf(" 3 --> /****************退出本次实验*********/\n");
    	printf("   请输入相应的数字来选择你要进行的操做(注意只能输入1,2,3中的一个,否则将输出error):");
    
    	scanf("%d",&i);
    
    	/*switch(i)
    	{
    	case 1:
    		Bank(Flag0);
    		break;
    
    	case 2:
    		checkSecurity (Flag1);
    		break;
    
    	case 3:
    		C
    
    	}*/
    	if(i==1)
        {
            Bank(Flag0);
            break;
        }
        else if(i==2)
        {
            checkSecurity (Flag1);
    		break;
        }
        else if(i==3)
        {
            return 0;
        }
        else
        {
            printf("error  (输入错误 请重新输入)\n");
        }
    	}
    }
    /****************初始化算法***************************/
    void Init()
    {
    	int i,j;
    	printf ("请输入进程的数目并按回车:\n");
    	scanf ("%d",&m);
    	printf ("请输入资源的种类:\n");
    	scanf ("%d",&n);
    	printf ("请输入每个进程对资源的最大需求量,按照[%d*%d]矩阵输入(构建 Max 矩阵):\n",m,n);
    	 for (i=0;i<m;++i)
    	  {
    	  	for (j=0;j<n;++j)
    	  	 scanf ("%d",&Max[i][j]);
    	  }
    	printf ("请输入每个进程已经分配的各类资源数量,按照[%d*%d]矩阵输入(构建 Allocation 矩阵):\n",m,n);
    	  for (i=0;i<m;++i)
    	  {
    	  	for (j=0;j<n;++j)
    	  	  {
    		    scanf ("%d",&Allocation[i][j]);
    
    	       }
    	     }
    	 printf ("获得 Need 矩阵的值为:\n");
    	 {
    	 	 for (i=0;i<m;++i)
    	 	 {
    	 	 	for (j=0;j<n;++j)
    	 	 	{
    	 	 		Need[i][j] = Max[i][j]-Allocation[i][j];
    	 	 	    printf ("%d ",Need[i][j]);
    			}
    			printf ("\n");
    
    	  	    if (Need[i][j]<0)
    	       {
    			  printf ("第%d行第%d个资源错误,请重新输入:\n",i+1,j+1);
    	         j--;
    	         continue;
    		  }
    	     }
    
    	  }
    
    	printf ("请输入各类资源剩余量:\n");
    	 for (i=0;i<n;++i)
    	  scanf ("%d",&Available[i]);
    
    	printf ("进程的全部信息如下:\n");
    	printf ("进程名\tMax\t\tAllocation\tNeed\n");
    	for (int i=0;i<m;++i)
    	{
    		printf ("P%d\t",i);
    		for (int j=0;j<n;++j)
    		{
    			printf ("%d ",Max[i][j]);
    		}
    		printf ("\t");
    			for (int j=0;j<n;++j)
    		{
    			printf ("%d ",Allocation[i][j]);
    		}
    		printf ("\t");
    			for (int j=0;j<n;++j)
    		{
    			printf ("%d ",Need[i][j]);
    		}
    		printf ("\n");
    	}
    	printf ("目前可利用的资源量 Available:\n");
    	for (int i=0;i<n;i++)
    	{
    		printf ("%d ",Available[i]);
    	}
    	printf ("\n");
     }
    /*****************安全性检测算法****************/
    bool checkSecurity (int Flag)
    {
    	int i,j,k,l=0;
    	int Work[100];///可以用的资源数组;
    	for (i=0;i<n;++i)
    	{
    		Work[i] = Available[i];///赋初值
    	}
    	for (i=0;i<m;++i)
    	{
    		Finish[i]=false;///Finish 记录每个进程是否安全
        }
    
    	for (i=0;i<m;++i)
    	{
    		if (Finish[i]==true)
    		  continue;
    		else
    		 {
    			for (j=0;j<n;++j)/**循环查找第i个进程所需的各个资源数是否超过系统现有的第j个资源数*/
    	     	{
    		     	if (Need[i][j]>Work[j])/**如果第i个进程所需的第j个资源数超过系统现有的第j个资源数,则拒绝申请*/
    			 	 	break;
    		    }
    
    			if (j == n)/**如果第i个进程所需的各个资源数没有超过系统现有的资源数*/
    		 	{
    		    	Finish[i]=true;
    		    	for (k=0;k<n;++k)
    		       		Work[k]=Work[k]+Allocation[i][k];/**将第i个进程各个已分配资源数+系统有的对应资源数赋值给Work*/
    		    	p[l++]=i;
    		    	 i=-1;///记录进程号;
    	      	}
    			else ///如果超过则继续循环执行下一个过程
    		 	{
    				continue;
    			}
    		}
    
            if (Flag==0)
    		{
    			if (l == m)/**如果所有的进程都能够被满足运行时*/
    		    {
    				printf ("系统是安全的!\n");
    				printf ("安全序列为:\n");
    				for (i=0;i<l;++i)///显示资源分配给进程的顺序;
    				{
    					printf ("%d",p[i]);
    					if(i != l-1)///输出箭头
    					printf ("-->");
    				}
    				printf ("\n");
    				return true;
    			}
    			else
    			{
    			    printf ("系统是不安全的!\n");
    	            return false;
    			}
    
    		}
    		else if (Flag==1)
    		{
    			show ();
    		}
    
    
        }//for循环
    	    return 0;
    }
    /******************银行家算法的实现********************/
    int Bank(int Flag)
    {
    
       while (1)
        {
    		int mi,i;
    		printf ("请输入要申请资源的进程号:  (第一个进程号为0,第二个进程号为1,以此类推)\n");
    		scanf ("%d",&mi);
    		printf ("请输入进程所请求得各个资源的数量:\n");
    		for (i=0;i<n;++i)
    	     {
    			scanf ("%d",&Request[mi][i]);
    		 }
    		for (i=0;i<n;++i)
    		 {
    			if (Request[mi][i]>Need[mi][i])
    			 {
    				printf ("所请求的资源超过进程进程的需求量!\n");
    				return 0;
    			 }
    			if (Request[mi][i]>Available[i])
    			 {
    				printf ("所请求的资源超过系统现有的资源数!\n");
    				return 0;
    			 }
    
    		 }
    		for (i=0;i<n;++i)
    		 {
    			if ( Request[mi][i] <= Need[mi][i] && Request[mi][i] <= Available[i] )
    			 {
    				Available[i] = Available[i]-Request[mi][i];
    				Allocation[mi][i] = Allocation[mi][i]+Request[mi][i];
    				Need[mi][i] = Need[mi][i]-Request[mi][i];
    			 }
    			if (checkSecurity (Flag))
    			 {
    				printf ("同意您的分配请求!\n");
    			 }
    			else
    			 {
    				printf ("您的请求被拒绝!\n");
    				for (i=0;i<n;++i)
    				 {
    				   Available[i] = Available[i]-Request[mi][i];
    			  	   Allocation[mi][i] = Allocation[mi][i]+Request[mi][i];
    				   Need[mi][i] = Need[mi][i]-Request[mi][i];
    				 }
    			 }
    			for (i=0;i<m;i++)
    			 {
    			 	 Finish[i]=false;
    			 }
    
    			char Fl;/**设置一个标志位*/
    			printf ("是否再次请求分配?是请按Y/有,否请按N/n\n");
    			while(1)
    			 {
    				scanf ("%c\n",&Fl);
    				if (Fl == 'Y'||Fl == 'y'||Fl == 'N'||Fl == 'n')
    				 break;
    				else
    				 {
    					printf ("请重新输入:\n");
    					continue;
    				 }
    			 }
    			 if (Fl == 'Y'||Fl == 'y')
    			   continue;
    			else
    			   break;
    	 }
       }
    }
    void show()
    {
    	int i;
    	for(i=0;i<m;i++) /**当前系统可满足%d进程的需求,分配资源给该进程。进程运行结束后,系统收回该进程%d的资源。*/
    		printf("第%d步,删除进程%d的边\n",i+1,p[i]);
    	printf ("当前环境不会发生死锁!\n");
    }
    
    
    
    
    展开全文
  • 操作系统银行家算法C语言实现,是一个正确无误的程序,与大家共分享
  • 银行家算法
  • c语言实现操作系统作业银行家算法,算法不是很复杂相信理解了算法就可以写的出来。其实代码还有些不足,望自行下去改进。 使用方法:编译后运行程序,输入保存文件绝对路径,一般在txt下,查看文件结果
  • 操作系统实验 银行家算法+实验报告 完整代码c语言实现
  • 这是用c语言编写的银行家算法,供大家参考,考虑的很全面,希望对大家有用
  • 银行家算法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}; //...

    银行家算法C语言实现

    #include<stdio.h>
    #include<stdlib.h>
    #define ok 1
    #define true 1
    #define error 0
    #define false 0
    
    int claim[100][100] = {0}; // 各个进程需要的最大资源数量
    int alloc[100][100] = {0}; // 各个进程已分配的资源数量
    int need[100][100] = {0};  // 各个进程还需要的资源数量
    int resource[100] = {0};   // 各个资源的总数
    char name[100] = {0};      // 各个资源的名字
    int available[100] = {0};  // 可分配的资源数
    int work[100] = {0};       // 用于存放alloc+available两个数组和的值
    int finish[100] = {0};     // 判断是否分配完成
    int ss[100] = {0};         // 安全序列
    int request[100] = {0};    // 请求单独分配的资源数量
    int n, m; // n:进程的数量 m:资源的种数
    
    int init()
    {
        int i, j;
        //char Name;
    
        printf("请输入进程所需资源的种数:");
        scanf("%d", &m);
        for(i = 0; i < m; i++)
        {
            printf("请输入资源%d的名字:", i);
            fflush(stdin);// 用于刷新缓冲区,VScode这里一定要这么做
            scanf("%c", &name[i]);
            //name[i] = Name;
            printf("请输入资源%c的资源总数:", name[i]);
            scanf("%d", &resource[i]);
        }
        printf("==============================\n");
        printf("请输入各个资源可分配的资源数:\n");
        for(i = 0; i < m; i++)
        {
            printf("%c:", name[i]);
            scanf("%d", &available[i]);
        }
        printf("==============================\n");
        printf("请输入进程的数量:");
        scanf("%d", &n);
        printf("请输入各个进程需要的最大资源数量:\n");
        for(i = 0; i < n; i++)
        {
            for(j = 0; j < m; j++)
                scanf("%d", &claim[i][j]);
        }
        printf("==============================\n");
        printf("请输入各个进程已分配的资源数量:\n");
        for(i = 0; i < n; i++)
        {
            for(j = 0; j < m; j++)
                scanf("%d", &alloc[i][j]);
        }
        return ok;
    }
    
    int safe()
    {
        int i, j, k, s = 0;
        int flag;
        int t;
    
        //初始化work数组,在available数组改变时用于替换available数组进行加法的运算。
        for(j = 0; j < m; j++)
            work[j] = available[j];
        //初始化finish数组,用于在分配完之后跳过这个进程。
        for(i = 0; i < n; i++)
            finish[i] = false;
        //算出各个进程还需要的各种资源的数量。
        for(i = 0; i < n; i++)
        {
            for(j = 0; j < m; j++)
            {
                need[i][j] = claim[i][j] - alloc[i][j];
            }
        }
        printf("==============================\n");
        printf("各个进程还需要的资源数量:\n");
        for(i = 0; i < n; i++)
            printf("%c ", name[i]);
            printf("\n");
        for(i = 0; i < n; i++)
        {
            for(j = 0; j < m; j++)
            {
                printf("%d ", need[i][j]);
            }
            printf("\n");
        }
        printf("==============================\n");
        printf("判断是否安全:");
        for(i = 0; i < n; i++)
        {
            t = 0;
            for(j = 0; j < m; j++)
            {
                if(work[j] >= need[i][j] && finish[i] == false)
                {
                    t++;
                    if(t == m)
                    {
                        for(k = 0; k < m; k++)
                        work[k] = work[k] + alloc[i][k];
                        finish[i] = true;
                        ss[s++] = i;
                        i = -1;//保证每次都从第一行开始找起
                    }
                }    
            }
        }
        for(i = 0; i < n; i++)
        {
            if(finish[i] == false)
            {   
                printf("不安全!");
                return error;
            }
        }
        printf("安全,存在一个安全序列:");
        for(i = 0; i < n; i++)
        {
            printf("P%d", ss[i]);
            if(i < n-1)
             printf("->");
        }
        printf("\n");
        return ok;
    }
    
    int  banker()
    {
        int p, i, j;
        int flag = true;
    
        printf("==============================\n");
        printf("请输入第几个进程请求分配的资源(0~%d):", n-1);
        scanf("%d", &p);
        printf("请分别输入请求分配的资源数量:\n");
        for(i = 0; i < m; i++)
        {
            printf("%c:", name[i]);
            scanf("%d", &request[i]);
        }
    
        for(j = 0; j < m; j++)
        {
            if((request[j] + alloc[p][j]) > claim[p][j])
            {
                printf("不合理\n");
                flag = false;
                break;
            }
            else
            {
                if(request[j] > available[j])
                {
                    printf("不可能\n");
                    flag = false;
                    break;
                }
            }
        }
    
        if(flag)
        {
            test(p);  // 尝试将请求的资源数量分配到请求的进程
            safe();
            reset(p); // 重置可分配的数组和已分配的数组
        }
        return ok;
    }
    
    int test(int i)
    {
        int j;
        for(j = 0; j < m; j++)
        {
            available[j] = available[j] - request[j];
            alloc[i][j] = alloc[i][j] + request[j];
        }
    }
    
    int reset(int i)
    {
        int j;
        for(j = 0; j < m; j++)
        {
            available[j] = available[j] + request[j];
            alloc[i][j] = alloc[i][j] - request[j];
        }
    }
    
    int main()
    {
        int t = 0;
    
        while(t != 4){
        printf("------------------------------\n");
        printf("        银行家算法模拟         \n");
        printf("------------------------------\n");
        printf("1: 初始化      2:判断是否安全\n");
        printf("3:请求分配     4:退出   \n");
        printf ("请选择(1~4):");
        scanf("%d", &t);
        switch(t)
            {
                case 1 :
                        init();
                    break;
                case 2:
                        safe();
                    break;
                case 3:
                        banker();
                    break;
                case 4 :
                        printf("银行家算法模拟结束Bye!");
                    exit(0);
            }
        }
        return 0;
    } 
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 个人编程,谨防重复!各位可以放心是使用,也可做个参考!
  • 算法根据课本的例子来实现死锁避免,大家多多提点意见啊O(∩_∩)O
  • 操作系统之——银行家算法C语言实现

    万次阅读 多人点赞 2016-12-05 21:41:14
    // 银行家算法.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "string.h" #include "stdlib.h" #define MAX_PROCESS 10 //进程数上限 #define MAX_RESOURCE_KIND 10 //资源种类上限 #...
    // 银行家算法.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include "string.h"
    #include "stdlib.h"
    
    #define MAX_PROCESS 10 //进程数上限
    #define MAX_RESOURCE_KIND 10 //资源种类上限
    #define MAX_RESOURCE_NUM 20	//每种资源可用数上限
    
    int resource;	//实际资源种类数
    int process;	//实际进程数
    int safe_list[MAX_PROCESS];	//安全序列
    
    struct AVAILABLE {	//可用资源向量
    	int resource_number; //资源数目
    	int work;	//工作向量	
    }Resource[MAX_RESOURCE_KIND], R_backup[MAX_RESOURCE_KIND];
    
    struct PROC {	//进程数据向量表
    	int max[MAX_RESOURCE_KIND];	//最大需求矩阵
    	int allocation[MAX_RESOURCE_KIND];	//分配矩阵
    	int need[MAX_RESOURCE_KIND];	//需求矩阵
    	bool finish;	//满足标记
    }Process[MAX_PROCESS], P_backup[MAX_PROCESS];
    
    void zero();
    void show_me();
    void init();
    void init_allocation();
    void update();
    void backup();
    void re_backup();
    bool allocation();
    bool one_allocation(int a, int b, int c);
    bool release();
    bool one_release(int a, int b, int c);
    int is_safe();
    void test();
    int banker();
    void menu();
    
    void zero() {//清零
    	for (int i = 0; i<MAX_RESOURCE_KIND; i++) {
    		Resource[i].resource_number = 0;
    	}
    	for (int i = 0; i<MAX_RESOURCE_KIND; i++) {
    		for (int j = 0; j< MAX_RESOURCE_KIND; j++) {
    			Process[i].max[j] = 0;
    			Process[i].allocation[j] = 0;
    			Process[i].need[j] = 0;
    		}
    	}
    }
    
    
    void show_me() {//绘制矩阵
    	printf("\n  Available矩阵  ");
    	for (int i = 0; i < resource; i++) {
    		printf("%d ", Resource[i].resource_number);
    	}
    	printf("\n");
    	printf("\n  Max矩阵");
    	for (int i = 0; i < MAX_RESOURCE_KIND *2-7; i++) printf(" ");
    	printf("Allocation矩阵");
    	for (int i = 0; i < MAX_RESOURCE_KIND * 2 -14; i++) printf(" ");
    	printf("Need矩阵");
    	for (int i = 0; i < MAX_RESOURCE_KIND * 2 - 8; i++) printf(" ");
    
    	for (int i = 0; i<process; i++) {
    		printf("\n  ");
    		for (int j = 0; j<resource; j++) printf("%d ", Process[i].max[j]);
    		for (int i = 0; i < MAX_RESOURCE_KIND * 2 - resource*2; i++) printf(" ");
    		for (int j = 0; j<resource; j++)	printf("%d ", Process[i].allocation[j]);
    		for (int i = 0; i < MAX_RESOURCE_KIND * 2 - resource * 2; i++) printf(" ");
    		for (int j = 0; j<resource; j++) printf("%d ", Process[i].need[j]);	
    	}
    	printf("\n");	
    }
    
    
    void init() {//初始化
    	int n;
    	printf("\n输入资源种类数  ");
    	scanf("%d", &n);
    	resource = n;
    	for (int i = 0; i<resource; i++) {
    		printf("\n输入第%d种资源数量  ", i + 1);
    		scanf("%d", &n);
    		Resource[i].resource_number = n;
    	}
    	printf("\n输入进程数  ");
    	scanf("%d", &n);
    	process = n;
    	for (int i = 0; i<process; i++) {
    		int a, flag;
    		flag = 0;
    		printf("\n输入进程%d种资源使用数目  ", i + 1);
    		for (int j = 0; j<resource; j++) {
    			scanf("%d", &a);
    			Process[i].max[j] = a;
    			if (a>Resource[j].resource_number) flag = 1;
    		}
    		if (flag == 1) {
    			i--;
    			printf("\n需求超过资源上限请重新输入\n");
    		}
    		getchar();
    	}
    }
    
    void init_allocation() {//初始分配状态
    	for (int i = 0; i<process; i++) {
    		int a, flag;
    		flag = 0;
    		printf("\n输入进程%d当前资源占用情况  ", i + 1);
    		for (int j = 0; j<resource; j++) {
    			scanf("%d", &a);
    			Process[i].allocation[j] = a;
    			if (a>Resource[j].resource_number) flag = 1;
    		}
    		if (flag == 1) {
    			i--;
    			printf("\n当前资源占用超过资源上限请重新输入\n");
    		}
    	}
    	update();
    }
    
    
    void update() {//更新需求矩阵need和资源向量allocation
    	for (int i = 0; i<process; i++) {
    		for (int j = 0; j<resource; j++) {
    			Process[i].need[j] = Process[i].max[j] - Process[i].allocation[j];
    			Resource[j].resource_number -= Process[i].allocation[j];
    		}
    	}
    }
    bool allocation() {
    	backup();
    	printf("\n请输入 进程号以及对应资源所分配的数目用空格隔开\n");
    	int pro_num;
    	scanf("%d", &pro_num);
    	int aff[MAX_RESOURCE_KIND];
    	for (int i = 0; i < resource; i++) {
    		scanf("%d", &aff[i]);
    	}
    	for (int i = 0; i < resource; i++) {
    		if (one_allocation(pro_num-1, i, aff[i]) == false) {//调用单次分配函数尝试分配
    			re_backup();
    			return false;
    		}
    	}
    	return true;
    }
    
    bool one_allocation(int a, int b, int c) {//单次分配
    	if (c>Process[a].need[b]) {
    		printf("要求超过所需上限,请求失败\n");
    		return false;
    	}
    	else if (c>Resource[b].resource_number) {
    		printf("无足够资源,请求失败\n");
    		return false;
    	}
    	Resource[b].resource_number -= c;
    	Process[a].need[b] -= c;
    	Process[a].allocation[b] += c;
    	return true;
    }
    void backup() {		//数据备份
    	for (int i = 0; i < process; i++) {
    		P_backup[i] = Process[i];
    	}
    	for (int i = 0; i < resource; i++) {
    		R_backup[i] = Resource[i];
    	}
    }
    void re_backup() {	//数据还原
    	for (int i = 0; i < process; i++) {
    		Process[i] = P_backup[i];
    	}
    	for (int i = 0; i < resource; i++) {
    		Resource[i] = R_backup[i];
    	}
    }
    bool release() {	//释放资源
    	backup();
    	printf("\n请输入 进程号以及对应资源所分配的数目用空格隔开\n");
    	int pro_num;
    	scanf("%d", &pro_num);
    	int aff[MAX_RESOURCE_KIND];
    	for (int i = 0; i < resource; i++) {
    		scanf("%d", &aff[i]);
    	}
    	for (int i = 0; i < resource; i++) {
    		if (one_release(pro_num, i, aff[i]) == false) {
    			re_backup();
    			return false;
    		}
    	}
    	return true;
    }
    bool one_release(int a, int b, int c) {//资源释放
    	if (c>Process[a].allocation[b]) {
    		printf("释放超过所有上限,请求失败\n");
    		return false;
    	}
    	Resource[b].resource_number += c;
    	Process[a].need[b] += c;
    	Process[a].allocation[b] -= c;
    	return true;
    }
    
    int is_safe() {	//安全性检测算法
    
    	for (int i = 0; i < resource; i++) {
    		Resource[i].work = Resource[i].resource_number;
    	}
    	for (int i = 0; i < process; i++) {
    		Process[i].finish = false;
    		safe_list[i] = 0;
    	}
    	test();
    	bool flag = true;
    	for (int i = 0; i < process; i++) {
    		if (Process[i].finish == false) {
    			flag = false;
    			break;
    		}
    	}
    	if (flag == true) {
    		printf("\n系统状态安全");
    		printf("\n安全序列为  ");
    		for (int i = 0; i < process; i++) {
    			printf("%d ",safe_list[i]);
    		}
    		return 1;
    	}
    	else {
    		printf("\n系统状态不安全");
    		return -1;
    	}
    }
    
    
    void test() {	//安全性算法的递归分支
    	for (int i = 0; i < process; i++) {
    		bool flag=true;
    		if (Process[i].finish == false) {
    			for (int j = 0; j < resource; j++) {
    				if (Process[i].need[j] > Resource[j].work) {
    					flag = false;
    					break;
    				}
    			}
    			if (flag == true) {
    				for (int j = 0; j < resource; j++) {
    					Resource[j].work += Process[i].allocation[j];
    					Process[i].finish = true;
    				}
    				for (int k = 0; k < process; k++) {
    					if (safe_list[k] == 0) {
    						safe_list[k] = i + 1;
    						break;
    					}
    				}
    				test();	//递归处理
    			}
    		}
    	}
    }
    
    
    int banker() {//银行家算法
    	backup();	//备份
    	if (allocation() == false) return -1;
    	bool flag;
    	flag = is_safe();
    	if (flag == true) {
    		char k;
    		printf("\n是否分配(y/n)  ");
    		scanf("%c",&k);
    		if (k == 'y') return 1;
    		else {
    			re_backup();
    			return -1;
    		}
    	}
    	else {
    		re_backup();
    		return -1;
    	}
    }
    void menu() {	//菜单函数
    	printf("\n请输入指令\n");
    	printf("\n初始化(init) 显示数据矩阵(show) 判断安全性(safe)\n申请资源(request) 释放资源(release) 退出(quit)\n清屏(clear)\n");
    	char code[20];
    	while (1) {
    		printf("\n");
    		scanf("%s", code);
    		if (_stricmp(code, "init") == 0) {	//重置操作
    			zero();
    			init();
    			init_allocation();
    		}
    		else if (_stricmp(code, "show") == 0) {	//显示功能
    			show_me();
    		}
    		else if (_stricmp(code, "safe") == 0) {	//判断安全性
    			is_safe();
    		}
    		else if (_stricmp(code, "request") == 0) {	//申请资源
    			printf("\n是否使用银行家算法保证安全性(y/n)\n");
    			scanf("%s", code);
    			if (_stricmp(code, "y") == 0) banker();
    			else allocation();
    		}
    		else if (_stricmp(code, "release") == 0) {	//释放资源
    			release();
    		}
    		else if (_stricmp(code, "quit") == 0) {	//退出
    			return;
    		}
    		else if (_stricmp(code, "clear") == 0) {	//清屏
    			system("cls");
    			printf("\n请输入指令\n");
    			printf("\n初始化(init) 显示数据矩阵(show) 判断安全性(safe)\n申请资源(request) 释放资源(release) 退出(quit)\n清屏(clear)\n");
    		}
    		else printf("命令无效,请重新输入\n");
    	}
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	/*
    	zero();
    	init();
    	init_allocation();
    	show_me();
    	is_safe();*/
    	menu();
    	getchar();
    	return 0;
    }
    

    展开全文
  • 今天完成昨天的算法,银行家算法,这个大家如果知道操作系统这门课程的话应该会明白,昨天一直忙于复习,今天也是,不过下午还是完成了基本调试,调试环境GCC和TC,现在我把代码奉献给大家银行家算法说明:最早由...
  • 银行家算法C语言

    2011-12-21 21:32:55
    银行家算法C语言实现 操作系统实训程序 供大家参考
  • 银行家算法
  • 为了实现银行家算法,在系统中必须设置这样四个数据结构,分别用来描述系统中可用的资源,所有进程对资源的最大需求,系统中的资源分配,以及所有的进程话需要多少资源的情况。 1.可利用资源向量Available。这是一个...
  • 银行家算法C语言版 结构体 作用 allocation 已分配资源 max 最大需求资源 available 可分配的资源 need 需要的资源 path 进程运行的顺序 finish 满足要求的标志 #define _CRT_SECURE_NO_...
  • 操作系统银行家算法C语言代码实现

    千次阅读 2017-07-24 19:06:00
     实现过程中不涉及难度较大的算法,仅根据银行家算法的思想和步骤进行实现。以下为详细步骤:   定义: max1[ ][ ] : 最大需求矩阵,max1[i][j]为第i条进程的第j项资源的最大需求数目;  allo...
  • 银行家算法 c语言

    2010-04-16 20:41:01
    (1)若进程P1请求资源,发出请求向量Request1(1,0,2),编写程序用银行家算法判断系统能否将资源分配给它; (2)若进程P2提出请求Request(0,1,0),用银行家算法程序验证系统能否将资源分配给它。
  • C语言实现银行家算法

    2019-03-15 23:31:43
    使用C语言实现银行家算法,其中包括安全性算法和资源分配算法
  • 银行家算法是避免程序死锁的一条有效的算法!
  • 银行家算法C语言实现源文件)

    热门讨论 2012-07-02 22:32:22
    利用C语言实现操作系统中的银行家算法(话说说的这么清楚还需要多少描述吗?额,我这个是老师亲自验收通过的!)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,433
精华内容 1,373
关键字:

银行家算法c语言实现

c语言 订阅