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

本文主要是介绍课程设计-死锁的避免-C++，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

在此之间你需要创建三个文件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

像这样

#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();
	}
}

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

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

这篇关于课程设计-死锁的避免-C++的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

C/C++教程

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

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯