ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 编程语言> 文章详细

课程设计-死锁的避免-C++

2021-12-15 13:31:14  阅读：133  来源： 互联网

标签：课程设计 RESOURCE int MAX void list C++ PROCESS 死锁


 在此之间你需要创建三个文件Available_list.txt，Max_list.txt，Allocation_list.txt，把三个文件和程序放在同一个文件夹里，三个文件编写格式如下

available.txt

3(代表资源种类，括号里面的文字不用写，只是解释）

3 9 7（各种资源数量）

Max_list.txt

4（进程数量）

2 3 1

1 1 1

1 3 4

1 2 1

Allocation._list.txt

0 0 0 

0 0 1

1 0 1

1 0 1

像这样

 

#include <iostream>
#include <stdio.h>
#include <windows.h>//Windows内核API，图形界面接口，图形设备函数等重要的功能 
 
#define MAX_PROCESS 32              //最大进程数
#define MAX_RESOURCE 64              //最大资源类别
 
int PROCESS_NUM;              //实际总进程数
int RESOURCE_NUM;               //实际资源类别数
int Available[MAX_RESOURCE];                 //可利用资源向量
int Max[MAX_PROCESS][MAX_RESOURCE];          //最大需求矩阵
int Allocation[MAX_PROCESS][MAX_RESOURCE];   //分配矩阵
int Need[MAX_PROCESS][MAX_RESOURCE];         //需求矩阵
 
int Request_PROCESS;                       //发出请求的进程
int Request_RESOURCE_NUMBER[MAX_RESOURCE];     //请求资源数？？？？？ 
 
void Read_Available_list();      //读入可用资源Available
void Read_Max_list();           //读入最大需求矩阵Max
void Read_Allocation_list();    //读入已分配矩阵Allocation
void PrintInfo();               //打印各数据结构信息
void Read_Request();			//输入请求向量
void Allocate_Source();         //开始正式分配资源（修改Allocation_list.txt）
void Recover_TryAllocate();     //恢复试分配前状态
int Test_Safty();               //安全性检测
void RunBanker();               //执行银行家算法
using namespace std;
 
//读入可用资源Available
void Read_Available_list()      
{
	FILE *fp;
	if((fp=fopen("Available_list.txt","r"))==NULL)
	{ 
		cout<<"错误,文件打不开,请检查文件名"<<endl; 
		exit(0);
	}
	fscanf(fp,"%d",&RESOURCE_NUM);
	int i=0;
	while(!feof(fp))
	{
		fscanf(fp,"%d",&Available[i]);
		i++;
	}	
	fclose(fp);
}
 
//读入最大需求矩阵Max
void Read_Max_list()      
{
	FILE *fp;
	if((fp=fopen("Max_list.txt","r"))==NULL)
	{ 
		cout<<"错误,文件打不开,请检查文件名"<<endl; 
		exit(0);
	}
	fscanf(fp,"%d",&PROCESS_NUM);
	for(int i=0;i<PROCESS_NUM;i++)
		for(int j=0;j<RESOURCE_NUM;j++)
			fscanf(fp,"%d",&Max[i][j]);
	fclose(fp);
}
 
//读入已分配矩阵Allocation
void Read_Allocation_list()      
{
	FILE *fp;
	if((fp=fopen("Allocation_list.txt","r"))==NULL)
	{ 
		cout<<"错误,文件打不开,请检查文件名"<<endl; 
		exit(0);
	}
	for(int i=0;i<PROCESS_NUM;i++)
		for(int j=0;j<RESOURCE_NUM;j++)
			fscanf(fp,"%d",&Allocation[i][j]);
	fclose(fp);
}
 
//设置需求矩阵Need
void Set_Need()					
{                 
	for(int i=0;i<PROCESS_NUM;i++)
		for(int j=0;j<RESOURCE_NUM;j++)
		{
			Need[i][j]=Max[i][j]-Allocation[i][j];
			Available[j]=Available[j]-Allocation[i][j];
		}
}
 
//打印各数据结构信息
void PrintInfo()
{
	cout<<"进程个数： "<<PROCESS_NUM<<"\t"<<"资源个数： "<<RESOURCE_NUM<<endl;
	cout<<"可用资源向量Available："<<endl;
	int i,j;
	for(i=0;i<RESOURCE_NUM;i++)
		cout<<Available[i]<<"\t";
	cout<<endl;
	cout<<"最大需求矩阵Max："<<endl;
	for(i=0;i<PROCESS_NUM;i++)
	{
		for(j=0;j<RESOURCE_NUM;j++)
			cout<<Max[i][j]<<"\t";
		cout<<endl;
	}
	cout<<"已分配矩阵Allocation："<<endl;
	for(i=0;i<PROCESS_NUM;i++)
	{
		for(j=0;j<RESOURCE_NUM;j++)
			cout<<Allocation[i][j]<<"\t";
		cout<<endl;
	}
	cout<<"需求矩阵Need："<<endl;
	for(i=0;i<PROCESS_NUM;i++)
	{
		for(j=0;j<RESOURCE_NUM;j++)
			cout<<Need[i][j]<<"\t";
		cout<<endl;
	}
}
 
//输入请求向量
void Read_Request()			 
{                          
	cout<<"输入发起请求的进程（1－"<<PROCESS_NUM<<")：";
	cin>>Request_PROCESS;
 
	cout<<"输入请求资源的数目：按照这样的格式输入 x x x：";
	for(int i=0; i<RESOURCE_NUM; i++)
		cin>>Request_RESOURCE_NUMBER[i];
}
 

 
 
//安全性检测
//返回值：0：未通过安全性测试； 1：通过安全性测试
int Test_Safty()
{                        
	//请完成安全性检测算法的编程
	cout<<'\n'<<" 进入安全性检测	!"<<endl; 
	int i,j;
	int Work[MAX_RESOURCE];	//定义工作向量
	for(i=0;i<RESOURCE_NUM;i++){
		Work[i]=Available[i];
	}
	bool Finish[MAX_PROCESS];	// 定义布尔向量
	for(i=0;i<PROCESS_NUM;i++)
		Finish[i]=false;// finish表示进程是否由足够的资源分配给进程 
	int safe[MAX_RESOURCE];	// 用于保存安全序列
	bool found=false;	//判断在一轮查找中是否找到符合条件的进程 
	int FinishCount=0;		//找到满足条件的进程i 的数目 
	while(FinishCount<4)
	{
		for(i=0;i<PROCESS_NUM;i++)
		{
			if(Finish[i]==true) //	检查是否满足条件		Finish[i]==false 
				continue;
			bool HasResource=true;//有资源 
			for(j=0;j<RESOURCE_NUM;j++)	// 检查是否满足条件	Need[i]<=Work 
				if(Need[i][j]>Work[j])
					HasResource=false;
				if(HasResource)
				{
					for(j=0;j<RESOURCE_NUM;j++)
						Work[j]=Work[j]+Allocation[i][j];
					Finish[i]=true;
					safe[FinishCount]=i;
					FinishCount++; 
					found=true;
				}
		}
		if(found)
		{
			found=false;
		}
		else
			break;
	}
	for(i=0;i<PROCESS_NUM;i++)	// 判断是否所有进程满足	Finish[i]==true
	{
		if(Finish[i]==true)
			continue;
		else
			{
			cout<<" 未通过安全性测试，不分配	"<<endl;
			return 0;
		}
	}
	cout<<'\n'<<" 找到一个安全序列	:";
	for(i=0;i<PROCESS_NUM;i++)		//打印安全序列
		{
		cout<<"P"<<safe[i]; 
		if(i!=PROCESS_NUM-1)
			cout<<"--->";
	}
	cout<<'\n'<<" 已通过安全性测试	!"<<endl;
	return 1;
}
 
void RunBanker(){              //执行银行家算法
	cout<<endl;
	cout<<"开始执行银行家算法..."<<endl;
 
 
	for(int i=0;i<RESOURCE_NUM;i++)  //检查是否满足条件Request<=Need
		if(Request_RESOURCE_NUMBER[i]>Need[Request_PROCESS][i])
		{
			cout<<"\n第"<<Request_PROCESS<<"个进程请求资源不成功"<<endl;
			cout<<"原因：超出该进程尚需的资源的最大数量!"<<endl;
			return;
		}
	for(int i=0;i<RESOURCE_NUM;i++)   //检查是否满足条件Request<=Available
		if(Request_RESOURCE_NUMBER[i]>Available[i])
		{
			cout<<"\n第"<<Request_PROCESS<<"个进程请求资源不成功"<<endl;
			cout<<"原因：系统中无足够的资源!"<<endl;
			return;
		}
		else{
			//试分配，更新各相关数据结构
			Available[i]=Available[i]-Request_RESOURCE_NUMBER[i];
		    Allocation[Request_PROCESS][i]=Allocation[Request_PROCESS][i]+Request_RESOURCE_NUMBER[i];
	   	    Need[Request_PROCESS][i]=Need[Request_PROCESS][i]-Request_RESOURCE_NUMBER[i];
		}
	cout<<endl<<"试分配完成..."<<endl;
 
	if(Test_Safty())    //使用安全性算法检查，若满足，则正式分配
		Allocate_Source();
	else                //否则恢复试分配前状态
		Recover_TryAllocate();
}
//恢复试分配前状态
void Recover_TryAllocate()
{
	for(int i=0;i<RESOURCE_NUM;i++)
	{
		Available[i]=Available[i]+Request_RESOURCE_NUMBER[i];
		Allocation[Request_PROCESS][i]=Allocation[Request_PROCESS][i]-Request_RESOURCE_NUMBER[i];
	   	Need[Request_PROCESS][i]=Need[Request_PROCESS][i]+Request_RESOURCE_NUMBER[i];
	}
}
 
//开始正式分配资源（修改Allocation_list.txt）
void Allocate_Source()
{                       
	cout<<'\n'<<"开始给第"<<Request_PROCESS<<"个进程分配资源..."<<endl;
	FILE *fp;
	if((fp=fopen("Allocation_list.txt","w"))==NULL)
	{ 
		cout<<"错误,文件打不开,请检查文件名"<<endl; 
		exit(0);
	}
	for(int i=0;i<PROCESS_NUM;i++)
	{
		for(int j=0;j<RESOURCE_NUM;j++)
			fprintf(fp,"%d  ",Allocation[i][j]);
		fprintf(fp,"\n");
	}
	cout<<"分配完成，已更新Allocation_list.txt"<<endl;
	fclose(fp);
}
 
//::main' must return 'int,C语言标准允许main函数为void类型。按照C++的标准中main必须是int类型 
int  main()
{
	char c;
	Read_Available_list();//读不可抢占资源表 ，资源种类和各资源数量 
	Read_Max_list();//读进程(进程数，各进程所需的最大资源数） 
	Read_Allocation_list();//读分配表，现在已经分配的 ，初始化为0 
	Set_Need(); 
	PrintInfo();
	while(1)
	{
		Read_Request();//用户需求 
		RunBanker();//银行家算法 
		cout<<"\n\n需要继续吗？（y-继续；n-终止）";
		cin>>c;
		if(c=='n')
			break;
		cout<<endl<<endl;
		PrintInfo();
	}
}

一年一度的课程设计，却不知道根本原理，友情提醒各位用户，当我们输入数值时，如果我们没有出现安全序列，说明发生了死锁。

如果有问题，欢迎指正，有问题请教也可以，还有本代码只是借鉴别人的，并非本人一瘦创作，只是在原有的基础上进行了改编。

标签：课程设计,RESOURCE,int,MAX,void,list,C++,PROCESS,死锁
来源： https://blog.csdn.net/m0_49018281/article/details/121950083

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有