操作系统实验三

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++)
}
}
//打印各数据结构信息
void PrintInfo()
{
cout<<"进程个数："<<PROCESS_NUM<<"\t"<<"资源个数："<<RESOURCE_NUM<<endl;
cout<<"可用资源向量Available："<<endl;
int i,j;
for(i=0;i<RESOURCE_NUM;i++)
int RESOURCE_NUM; //实际资源类别数
int Available[MAX_RESOURCE]; //可利用资源向量
int Max[MAX_PROCESS][MAX_RESOURCE]; //最大需求矩阵
int Allocation[MAX_PROCESS][MAX_RESOURCE]; //分配矩阵
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]<<"\Fra Baidu bibliotek";
cout<<endl;
}
cout<<"已分配矩阵Allocation："<<endl;
fprintf(fp,"%d ",Allocation[i][j]);
fprintf(fp,"\n");
}
cout<<"分配完成，已更新Allocation_list.txt"<<endl;
fclose(fp);
}
//恢复试分配前状态
上述三个矩阵间存在关系：Need[i][j]=Max[i][j]-Allocation[i][j]；
三、银行家算法
Request是进程i的请求向量。Request[j]=k表示进程i请求分配j类资源k个。当进程i发出资源请求后，系统按下述步骤进行检查：
1．如果Request≤Need[i]，则转向步骤2；否则，认为出错，因为它所请求的资源数已超过它当前的最大需求量。
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++)
void Recover_TryAllocate(); //恢复试分配前状态
int Test_Safty(); //安全性检测
void RunBanker(); //执行银行家算法
//读入可用资源Available
void Read_Available_list()
{
FILE *fp;
if((fp=fopen("Available_list.txt","r"))==NULL)
广东海洋大学学生实验报告书（学生用表）
实验名称
实验3：死锁的避免—银行家算法
课程名称
操作系统
课程号
学院(系)
信息学院
专业
物联网工程
班级
1131
学生姓名
杨光
学号
201311672119
实验地点
实验日期
实验三
一、实验目的
1．掌握死锁产生的原因。
2．掌握银行家算法。
3．能使用高级语言模拟实现银行家算法。
二、相关数据结构
void Read_Max_list(); //读入最大需求矩阵Max
void Read_Allocation_list(); //读入已分配矩阵Allocation
void PrintInfo(); //打印各数据结构信息
void Read_Request();//输入请求向量
void Allocate_Source(); //开始正式分配资源（修改Allocation_list.txt）
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)
//**//
//**//
//* Allocation_list.txt*//
//* 0 1 0 //表示各个进程已分配各类资源的数目*//
//* 2 0 0*//
//* 3 0 2*//
//* 2 1 1*//
//* 0 0 2*//
//**//
//**//
//*************************************************************************//
代码如下：
#include <iostream.h>
#include <stdio.h>
#include <windows.h>
#define MAX_PROCESS 32 //最大进程数
#define MAX_RESOURCE 64 //最大资源类别
int PROCESS_NUM; //实际总进程数
//**//
//**//
//* Max_list.txt*//
//* 5 //表示共有5个进程*//
//* 7 5 3 //表示各个进程需要各类资源的最大数目，即Max[0][0]=7, Max[0][1]=5*//
//* 3 2 2*//
//* 9 0 2*//
//* 2 2 2*//
//* 4 3 3*//
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++)
void Set_Need_Available()
{
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];
for(int i=0; i<RESOURCE_NUM; i++)
cin>>Request_RESOURCE_NEMBER[i];
}
//开始正式分配资源（修改Allocation_list.txt）
void Allocate_Source()
{
cout<<'\n'<<"开始给第"<<Request_PROCESS<<"个进程分配资源..."<<endl;
Finish：它表示系统是否有足够的资源分配给进程，使之运行完成，开始Finish[i]=false；当有足够资源分配给进程i时，令Finish[i]=true；
2．从进程集合中找到一个能满足下述条件的进程。
Finish[i]= = false；
Need[i]≤work；
如找到则执行步骤3；否则，执行步骤4；
系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析。
程序框架已经给出，要求将安全性算法补充完整。
//***********************************************************************//
//*实验三死锁的避免――银行家算法*//
Need[i]= Need[i]- Request
4．系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。如果安全才正式将资源分配给进程i，以完成本次分配；否则，将试探分配作废，恢复原来的资源分配状态，让进程i等待。
四、安全性算法
1．设置两个向量。
Work：它表示系统可提供给进程继续运行的各类资源数目，它包含m个元素，开始执行安全性算法时，Work = Available。
//**//
//*本程序需要预先设置三个文件：Available_list.txt，Max_list.txt，Allocation_list.txt *//
//*各文件格式如下：*//
//* Available_list.txt*//
//* 3 //表示共有3类资源*//
//* 10 5 7 //表示各类资源的初始可用个数，即Available[0]=10, Available[1]=5 *//
2．如果Request≤Available，则转向步骤3；否则，表示系统中尚无足够的资源满足进程i的申请，进程i必须等待。
3．系统试探性地把资源分配给进程i，并修改下面数据结构中的数值：
Available = Available - Request
Allocation[i]= Allocation[i]+ Request
3．当进程i获得资源后，可顺利执行直到完成，并释放出分配给它的资源，故应执行
Work = work + Allocation[i]
Finish[i]=true；转向步骤2；
4．若所有进程的Finish[i]都为true，则表示系统处于安全状态；否则，系统处于不安全状态。
五、实验内容
设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。
{
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
3．分配矩阵Allocation，这是一个n×m的矩阵，它定义了系统中的每类资源当前分配到每一个进程的资源数。如果Allocation[i][j]=k，表示进程i当前已经分到j类资源的数目为k个。Allocation[i]表示进程i的分配向量。
4．需求矩阵Need，这是一个n×m的矩阵，用以表示每个进程还需要的各类资源的数目。如果Need[i][j]=k，表示进程i还需要j类资源k个，才能完成其任务。Need[i]表示进程i的需求向量。
{
cout<<"错误,文件打不开,请检查文件名"<<endl;
exit(0);
}
fscanf(fp,"%d",&RESOURCE_NUM);
int i=0;
while(!feof(fp))
{
fscanf(fp,"%d",&Available[i]);
i++;
}
fclose(fp);
}
//读入最大需求矩阵Max
int Need[MAX_PROCESS][MAX_RESOURCE]; //需求矩阵
int Request_PROCESS; //发出请求的进程
int Request_RESOURCE_NEMBER[MAX_RESOURCE]; //请求资源数
void Read_Available_list(); //读入可用资源Available
cout<<Need[i][j]<<"\t";
cout<<endl;
}
}
//输入请求向量
void Read_Request()
{
cout<<"输入发起请求的进程（0－"<<PROCESS_NUM-1<<")：";
cin>>Request_PROCESS;
cout<<"输入请求资源的数目：按照这样的格式输入x x x：";
1．可利用资源向量Available，它是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源的数目，其初始值是系统中所配置的该类全部可用资源数目。其数值随该类资源的分配和回收而动态地改变。如果Available[j]=k，标是系统中现有j类资源k个。
2．最大需求矩阵Max，这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i][j]=k，表示进程i需要j类资源的最大数目为k。