操作系统课程设计：银行家算法与随机分配算法（linux篇）

最新推荐文章于 2023-06-12 10:57:25 发布
最新推荐文章于 2023-06-12 10:57:25 发布
阅读量8.7k 收藏 31
点赞数 3
分类专栏： C/C++ 文章标签： 算法 linux allocation fp system include
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/toss156/article/details/7162506
版权
  
#include <stdio.h>

typedef struct
 {
	int	A;
	int	B;
	int	C;
}RES;

typedef int bool;
#define false 0
#define true  1

//系统中所有进程数量
#define PNUMBER	3

//最大需求矩阵
RES Max[PNUMBER];

//已分配资源数矩阵
RES Allocation[PNUMBER];

//需求矩阵
RES Need[PNUMBER];

//可用资源向量
RES Available={0,0,0};

//安全序列
int safe[PNUMBER];

void setConfig()
{
	int i=0,j=0;
    printf("================开始手动配置资源==================\n");
	
	//可分配资源
	scanf("%d%d%d",&Available.A,&Available.B,&Available.C);
	
	//最大需求矩阵MAX
	for (i=0;i<PNUMBER;i++)
	{
		scanf("%d%d%d",&Max[i].A,&Max[i].B,&Max[i].C);
	}
	
	//已分配矩阵Alloc
	for (i=0;i<PNUMBER;i++)
	{
		scanf("%d%d%d",&Allocation[i].A,&Allocation[i].B,&Allocation[i].C);
	}
	
	//需求矩阵
	for (i=0;i<PNUMBER;i++)
	{
		scanf("%d%d%d",&Need[i].A,&Need[i].B,&Need[i].C);
	}
    printf("================结束配置资源==================\n");

}

void loadConfig()
{
	FILE *fp1;

	if ((fp1=fopen("config.txt","r"))==NULL)
	{
		printf("没有发现配置文件,请手动输入!!!\n");
		setConfig();
	}
    else{  
			int i=0;
			printf("发现配置文件,开始导入..");
	
		
			//可分配资源
			fscanf(fp1,"%d%d%d",&Available.A,&Available.B,&Available.C);
			
			//最大需求矩阵MAX
			for (i=0;i<PNUMBER;i++)
			{
				fscanf(fp1,"%d%d%d",&Max[i].A,&Max[i].B,&Max[i].C);
			}
			//已分配矩阵Alloc
			for (i=0;i<PNUMBER;i++)
			{
				fscanf(fp1,"%d%d%d",&Allocation[i].A,&Allocation[i].B,&Allocation[i].C);
			}
			//需求矩阵
			for (i=0;i<PNUMBER;i++)
			{
				fscanf(fp1,"%d%d%d",&Need[i].A,&Need[i].B,&Need[i].C);
			}		
			
		printf("信息导入完成.....\n");
		
	}
	
    }

//试探分配
void ProbeAlloc(int process,RES *res)
{
	Available.A -= res->A;
	Available.B -= res->B;
	Available.C -= res->C;

	Allocation[process].A += res->A;
	Allocation[process].B += res->B;
	Allocation[process].C += res->C;

	Need[process].A -= res->A;
	Need[process].B -= res->B;
	Need[process].C -= res->C;
}

//若试探分配后进入不安全状态，将分配回滚
void RollBack(int process,RES *res)
{
	Available.A += res->A;
	Available.B += res->B;
	Available.C += res->C;

	Allocation[process].A -= res->A;
	Allocation[process].B -= res->B;
	Allocation[process].C -= res->C;

	Need[process].A += res->A;
	Need[process].B += res->B;
	Need[process].C += res->C;
}

//安全性检查
bool SafeCheck()
{
	RES	Work = Available;
	bool		Finish[PNUMBER] = {false,false,false};
	int		i;
	int		j = 0;

	for (i = 0; i < PNUMBER; i++)
	{
		//是否已检查过
		if(Finish[i] == false)
		{
			//是否有足够的资源分配给该进程
			if(Need[i].A <= Work.A && Need[i].B <= Work.B && Need[i].C <= Work.C)
			{
				//有则使其执行完成，并将已分配给该进程的资源全部回收
				Work.A += Allocation[i].A;
				Work.B += Allocation[i].B;
				Work.C += Allocation[i].C;
				Finish[i] = true;
				safe[j++] = i;
				i = -1;				//重新进行遍历
			}
		}
	}

	//如果所有进程的Finish向量都为true则处于安全状态，否则为不安全状态
	for (i = 0; i < PNUMBER; i++)
	{
		if (Finish[i] == false)
		{
			return false;
		}
	}
	return true;
}

//资源分配请求
bool request(int process,RES *res)
{
	//request向量需小于Need矩阵中对应的向量
	if(res->A <= Need[process].A && res->B <= Need[process].B && res->C <= Need[process].C)
	{
		//request向量需小于Available向量
		if(res->A <= Available.A && res->B <= Available.B && res->C <= Available.C)
		{
			//试探分配
			ProbeAlloc(process,res);

		
			//如果安全检查成立，则请求成功，否则将分配回滚并返回失败
			if(SafeCheck())
			{
				return true;
			}
			else
			{
				printf("安全性检查失败。原因：系统将进入不安全状态，有可能引起死锁。\n");
				printf("正在回滚...\n");
				RollBack(process,res);
			}
		}
		else
		{
			printf("安全性检查失败。原因：请求大于可利用资源。\n");
		}
	}
	else
	{
		printf("安全性检查失败。原因：请求大于需求。\n");
	}
	return false;
}

//输出资源分配表
void PrintTable()
{
	printf("===================================资源分配表==================================\n");
	printf("Process		Max          Allocation          Need          Available\n");
	printf("	   A    B    C      A    B     C      A     B     C     A    B   C\n");
	printf("  P0      %2d   %2d   %2d     %2d   %2d    %2d     %2d    %2d    %2d    %2d   %2d  %2d\n",Max[0].A,Max[0].B,Max[0].C,Allocation[0].A,Allocation[0].B,Allocation[0].C,Need[0].A,Need[0].B,Need[0].C,Available.A,Available.B,Available.C);
	printf("  P1      %2d   %2d   %2d     %2d   %2d    %2d     %2d    %2d    %2d\n",Max[1].A,Max[1].B,Max[1].C,Allocation[1].A,Allocation[1].B,Allocation[1].C,Need[1].A,Need[1].B,Need[1].C);
	printf("  P2      %2d   %2d   %2d     %2d   %2d    %2d     %2d    %2d    %2d\n",Max[2].A,Max[2].B,Max[2].C,Allocation[2].A,Allocation[2].B,Allocation[2].C,Need[2].A,Need[2].B,Need[2].C);
	printf("===============================================================================\n");

}

//银行家算法分配
void banker()
{
	int	ch;
	//判断输入的是否是安全状态
	PrintTable();
	printf("先检查初始状态是否安全。\n");
	if (SafeCheck())
	{
		printf("系统处于安全状态。\n");
		printf("安全序列是{P%d,P%d,P%d}。\n",safe[0],safe[1],safe[2]);
	}
	else
	{
		printf("系统处于不安全状态。程序将退出...\n");
		printf("执行完毕。\n");
		getchar();
		return ;
	}
	//开始分配
	do 
	{
		int		process;
		RES	res;
		
		printf("请依次输入请求分配的进程和对三类资源的请求数量：");
		scanf("%d%d%d%d",&process,&res.A,&res.B,&res.C);
      		if(process<3 && process>=0){
			if (request(process,&res))
			{
				printf("分配成功。\n");
				PrintTable();
				printf("安全序列是{P%d,P%d,P%d}。\n",safe[0],safe[1],safe[2]);
			}
			else
			{
				printf("分配失败。\n");
			}
			printf("是否继续分配？(Y/N):");
			getchar();
			ch = getchar();
		}else
		{
			printf("输入的进程号0～2\n");
			ch = 'y';
		}
	} while (ch == 'Y' || ch == 'y');

		printf("执行完毕。\n");
}



//随机分配算法执行
bool RandRequest(int process,RES *res)
{
	
		//request向量需小于Available向量
		if(res->A <= Available.A && res->B <= Available.B && res->C <= Available.C)
		{
			//试探分配
			ProbeAlloc(process,res);
			
			//判断进程是否执行完，执行完释放资源
			if(Max[process].A <= Allocation[process].A && Max[process].B <= Allocation[process].B && Max[process].C <= Allocation[process].C)
			{
				printf("\nP%d 执行完毕，释放所分配的资源...\n",process);

				//有则使其执行完成，并将已分配给该进程的资源全部回收
				Available.A += Allocation[process].A;
				Available.B += Allocation[process].B;
				Available.C += Allocation[process].C;
				
				 Allocation[process].A = 0;
				 Allocation[process].B = 0;
				 Allocation[process].C = 0;

				 Need[process].A = Max[process].A;
				 Need[process].B = Max[process].B;
				 Need[process].C = Max[process].C;
			
			}
			return true;
		}
		else
		{
			printf("分配失败。原因：请求大于可利用资源。\n");
		}

	return false;
}


//随机分配
void randPatch()
{
	int	ch;
	//判断输入的是否是安全状态
	PrintTable();
	printf("先检查初始状态是否安全。\n");
	if (SafeCheck())
	{
		printf("系统处于安全状态。\n");
		printf("安全序列是{P%d,P%d,P%d}。\n",safe[0],safe[1],safe[2]);
	}
	else
	{
		printf("系统处于不安全状态。程序将退出...\n");
		printf("执行完毕。\n");
		getchar();
		return ;
	}
	//开始分配
	do 
	{
		int		process;
		RES	res;
		
		printf("请依次输入请求分配的进程和对三类资源的请求数量：");
		scanf("%d%d%d%d",&process,&res.A,&res.B,&res.C);
		if (RandRequest(process,&res))
		{
			printf("分配成功。\n");
			PrintTable();
			if(!SafeCheck())
			{
				printf("系统发生死锁。");
				getchar();
			        getchar();	
				break;
			}
		}
		else
		{
			printf("分配失败。\n");
		}
		printf("是否继续分配？(Y/N):");
		getchar();
		ch = getchar();
		
	} while (ch == 'Y' || ch == 'y');
	
	printf("执行完毕。\n");
}


int main()
{
	
	int x;
	while(1)
	{
		system("clear");
		printf("===============================================================================\n");
		printf("\t\t\t共享资源分配与银行家算法\n");
		printf("===============================================================================\n");
		printf("\t\t\t 按1.导入配置信息\n");
		printf("\t\t\t 按2.银行家算法\n");
		printf("\t\t\t 按3.随机分配算法\n");
		printf("\t\t\t 按0.退出系统\n");
		printf("===============================================================================\n");
		printf("您输入的是:");
		scanf("%d",&x);
		fflush(stdin);
		system("clear");
		printf("===============================================================================\n");
		printf("\t\t\t共享资源分配与银行家算法");
		if (x == 2)
		{
			printf("\t---银行家算法\n");
		}else if(x==3)
		{
			printf("\t---随机分配算法\n");
		}
		printf("===============================================================================\n");
	
		switch(x)
		{
		case 1: 
			{
				//加载配置文件
				loadConfig();
				//打印资源分配表
				PrintTable();
			        getchar();
				getchar();
			};break;
		case 2: banker();break;
		case 3: randPatch(); break;
		case 0: return 0;break;
		default:printf("请输入0~1之间的数字\n"); 
		}
		
	}


	
	return 0;
}

念风2012
关注
专栏目录
【专栏必读】王道考研408操作系统+Linux系统编程万字笔记、题目题型总结、注意事项、目录导航和思维导图
快乐江湖的博客
10-27 2万+
王道408考研操作系统)第一章计算机系统概述-第一节1、2：操作系统概念、概念和特征1：理解fork的作用prinf("还没有执行fork函数的本进程为：%d\n" , getpid());//其返回值是pid类型的 sleep(1);if(ret > 0) //父进程返回的是子进程ID {printf("我是父进程，我的id是：%d,我的孩子id是%d\n" , getpid() , ret);sleep(1);} } else if(ret == 0) //子进程fork返回值是0 {.........
银行家算法linux下实现
05-05
这是关于银行家算法的linux下实现的代码，由于技术有限，其中若有bug，可与本人联系，yym112358@163.com
随机分配算法
12-11
随机分配算法
操作系统课程设计-银行家算法与随机分配算法
Iguodala的博客
02-17 7414
首先声明，以下代码参考了这位大牛。 但是这位大牛直接给出的代码，其中算法进行了优化也没有比较好的解释，这里我分析了好多时间。 程序主要就是进程模拟和算法实现，比较容易理解。 接着是对银行家算法优化的说明：(直接粘贴自己实验报告上的) 安全性算法：满足available和need的关系后，即满足安全性检查进行请求分配。满足request和need的关系以及request和av
大二下学期操作系统课程设计银行家算法资源分配和随机分配算法
zcp773344的博客
07-05 3816
#include &lt;string.h&gt; #include &lt;iostream.h&gt; #define FALSE 0 #define TRUE 1 #define W 4 //最大进程数W=4 #define R 10 //最大资源种类数 int M ; //输入总进程数 int N ; //输入资源的种类数 int p[W]; ...
操作系统银行家算法
12-22
在实际操作系统中，如Windows、Linux等，虽然并不直接使用银行家算法，但其设计理念被广泛借鉴，例如资源预留、优先级反转和饥饿问题的解决。 在提供的“操作系统银行家算法”压缩包文件中，很可能包含了一个实现...
【避免进程死锁】银行家算法
Marck的博客
04-13 4276
一、概述 银行家算法（Banker’s Algorithm）是一个避免进程死锁的著名算法，由 Dijkstra 于 1965 年提出。本文为笔者的读书笔记，结构如下： 死锁 银行家算法 例子展示 补充：鸵鸟算法和实际系统中对死锁的处理方式 二、死锁 既然银行家算法就是为了解决进程死锁而出现的，那么首先我们应该先来了解下什么是死锁，以及死锁产生的4个条件。 2.1 什么是死锁 如果一组进程中的每...
c模拟linux进程管理课程设计,操作系统课程设计
weixin_33104731的博客
04-28 880
一、设计目的本课程设计是学生学习完《操作系统原理》课程后，进行的一次全面的综合训练，通过课程设计，让学生更好地掌握操作系统的原理及实现方法，加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。二、设计要求从课程设计的目的出发，通过设计工作的各个环节，达到以下教学要求：两人一组，每组从所给题目中任选一个(如自拟题目，需经指导教师同意)，每个学生必须独立完成课程设计，不能相互抄袭，同组者文档不...
计算机操作系统OS教程 计算机基础课程 第2章 进程管理（1） 共79页.ppt
01-29
经典的进程同步问题包括哲学家就餐问题、生产者-消费者问题、读者-写者问题和银行家算法等。这些问题揭示了在并发环境中可能出现的资源竞争和同步需求，为设计有效的同步策略提供了理论基础。 2.5 进程通信 进程...
银行家算法、随机分配、按序分配资源分配
04-05
可以通过银行家算法、随机分配算法和按序分配算法实现资源分配
随机分配算法matlab代码-random:随机性（作为效率的来源）算法
05-26
随机分配算法matlab代码随机性是效率的来源 控制部分的随机化是自然策略的基本概念 使用随机化可以通过付出很小的可靠性代价来显着提高效率。 快速随机算法比慢速确定性算法更可靠。 LSH算法 基于随机比特采样的LSH 我们的kNN算法 在汉明距离中查找k个近邻，而无需评估该汉明距离的实际值。 使用上面的随机性算法。 rbslsh C ++中的实现 matlab.md-Matlab编码技巧 向量化 [写时复制机制] 1仅在看到输入数据被修改时才透明地分配数据的临时副本。 [就地数据操作] 1表示修改原始数据块，而不是使用修改后的数据创建新块，从而节省了任何内存分配和释放。 就地优化 从函数返回数据时，我们应尽可能尝试更新原始数据变量，从而避免分配新变量。 进行性能分析以提高性能 数值计算
红包随机分配算法
05-12
红包随机分配算法
共享资源分配与银行家算法
06-28
共享资源分配与银行家算法 计算机操作系统课程设计 资料由：若云№星辰提供
随机分配算法（Intege）
咫尺天涯
01-08 4047
参考资料： [url]http://blog.csdn.net/yaerfeng/article/details/18362623[/url] [url]http://www.zuidaima.com/code/file/2214023444104192.htm?dir=/2214023444104192.java[/url] 以下为抢红包的随机分配的Integer实现，主要参考以：抢红包的...
随机平均分配算法
最新发布
qq_58970479的博客
06-12 628
随机平均分配算法
【算法学习】基于“平均”的随机分配算法（贪婪，回溯），以按平均工作量随机分配单位为例
写Bug的小白的博客
11-10 8539
一、背景介绍   在工作中，遇到一个需求：将 N 个单位随机分配给 n 个人，其中每个单位有对应的工作量，分配时要尽量按工作量平均分给 n 个人，且人员的所属单位不能包括在被分配的单位中（N &amp;amp;gt;= n）。例如：有三个部门分给两个人([A]属于部门2和[B]属于部门3)，部门1的工作量是999，部门2是2，部门3是4，这样分配结果为 A分配部门3或部门1和部门3，B分配部门1和部门2或部门2。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值