操作系统课程设计-银行家算法.doc

操作系统课程设计_银行家算法

———————————————————————————————— 作者：
———————————————————————————————— 日期：

2

个人收集整理 勿做商业用途

《操作系统——银行家算法》

课程设计报告

姓 名： 赵又廷
学 号：012646234
班 级：05计科12班
专 业：计算机科学与技术

西安工业大学 计算机科学与信息学院

目 录

1 课程设计目的 …………………………………………………… 1
2 课程设计的要求 ………………………………………………… 1
3 课程设计题目描述 ……………………………………………… 2
4 课程设计之银行家算法原理 …………………………………… 2
5 源程序结构分析及代码实现 …………………………………… 4
6 课程设计总结 …………………………………………………… 25
一、课程设计的目的
操作系统是计算机系统的核心系统软件，它负责控制和管理整个系统的资源并组织用户协调使用这些资源,使计算机高效的工作。《操作系统课程设计》是《操作系统》理论课的必要补充，是复习和检验所学课程的重要手段,本课程设计的目的是综合应用学生所学知识，通过实验环节，加深学生对操作系统基本原理和工作过程的理解,提高学生独立分析问题、解决问题的能力，增强学生的动手能力。
二、课程设计的要求
1．分析设计内容，给出解决方案（要说明设计实现的原理，采用的数据结构）。
2．画出程序的基本结构框图和流程图。
3．对程序的每一部分要有详细的设计分析说明。
4．源代码格式要规范。
5．设计合适的测试用例，对得到的运行结果要有分析。
6．设计中遇到的问题,设计的心得体会。
7．按期提交完整的程序代码、可执行程序和课程设计报告.

三、课程设计题目描述
银行家算法是一种最有代表性的避免死锁的算法.
　　要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
　　安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn,则系统处于安全状态。安全状态一定是没有死锁发生。
　　不安全状态：不存在一个安全序列.不安全状态不一定导致死锁。
　　那么什么是安全序列呢？
　　安全序列:一个进程序列{P1，…,Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj （j 〈 i ）当前占有资源量之和。
　　银行家算法：
　　我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源,若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配.本文为互联网收集，请勿用作商业用途本文为互联网收集，请勿用作商业用途

四、 课程设计之银行家算法原理
1．银行家算法的思路
先对用户提出的请求进行合法性检查，即检查请求的是不大于需要的，是否不大于可利用的。若请求合法，则进行试分配。最后对试分配后的状态调用安全性检查算法进行安全性检查。若安全，则分配，否则，不分配，恢复原来状态,拒绝申请。

2．银行家算法中用到的主要数据结构
可利用资源向量 int Available［j] j为资源的种类。
最大需求矩阵 int Max［i］[j］ i为进程的数量。
分配矩阵 int Allocation[i]［j］
需求矩阵 int need[i]［j]= Max[i]［j]— Allocation［i][j]
申请各类资源数量 int Request i[j］ i进程申请j资源的数量
工作向量 int Work［x］ int Finish[y]

3．银行家算法bank(）
进程i发出请求申请k个j资源，Request i[j］=k
（1)检查申请量是否不大于需求量：Request i［j]<=need［i,j］,若条件不符重新输入,不允许申请大于需求量。
(2)检查申请量是否小于系统中的可利用资源数量：Request i［j]〈=available[i,j],若条件不符就申请失败，阻塞该进程，用goto语句跳转到重新申请资源.
（3）若以上两个条件都满足，则系统试探着将资源分配给申请的进程,并修改下面数据结构中的数值：
Available［i,j］= Available［i,j]- Request i[j］；
Allocation[i][j］= Allocation［i］[j]+ Request i［j］；
need［i][j]= need［i]［j]— Request i［j］;
（4）试分配后，执行安全性检查，调用safe(）函数检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程；否则本次试探分配作废,恢复原来的资源分配状态，让该进程等待.
（5）用do{…}while 循环语句实现输入字符y/n判断是否继续进行资源申请.

4．安全性检查算法(safe()函数)
（1）设置两个向量：
工作向量Work,它表示系统可提供给进程继续运行所需的各类资源数目,在执行安全性算法开始时,Work= Available。
Finish，它表示系统是否有足够的资源分配给进程,使之运行完成。开始时先做Finish［i]=0；当有足够的资源分配给进程时,再令Finish[i]=1。

(2)在进程中查找符合以下条件的进程：
条件1：Finish［i]=0;
条件2：need［i]［j]〈=Work[j］
若找到，则执行步骤(3）否则，执行步骤(4)

(3)当进程获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work［j］= Work[j]+ Allocation［i］[j］;
Finish[i］=1;
goto step 2;

（4)如果所有的Finish［i］=1都满足，则表示系统处于安全状态,否则，处于不安全状态。

五、源程序结构分析及代码实现

1．程序结构

程序共有以下五个部分：

(1) 。初始化chushihua(）:用于程序开始进行初始化输入数据：进程数量、资源种类、各种资源可利用数量、各进程的各种资源已分配数量、各进程对各类资源最大需求数等。
（2）。当前安全性检查safe（)：用于判断当前状态安全性，根据不同地方的调用提示处理不同。
(3).银行家算法bank():进行银行家算法模拟实现的模块，调用其他各个模块进行银行家算法模拟过程。
(4)。显示当前状态show(）:显示当前资源分配详细情况,包括：各种资源的总数量(all)、系统目前各种资源可用的数量、各进程已经得到的资源数量、各进程还需要的资源量。
(5)。主程序main(）
逐个调用初始化、显示状态、安全性检查、银行家算法函数，使程序有序的进行。

2．数据结构
程序使用的全局变量：
const int x=10,y=10； //定义常量
int Available［x]； //各种资源可利用的数量
int Allocation[y］[y]; //各进程当前已分配的资源数量
int Max［y］[y]； //各进程对各类资源的最大需求数
int Need[y］[y]; //还需求矩阵
int Request[x］; //申请各类资源的数量
int Work[x］； //工作向量，表系统可提供给进程运行所需各类资源数量
int Finish[y]; //表系统是否有足够的资源分配给进程，0为否，1为是
int p［y]； //存储安全序列
int i,j； //全局变量，主要用于循环语句中
int n，m; //n为进程的数量，m为资源种类数
int l=0，counter=0;

3．函数声明
void chushihua（)； 　　//系统初始化函数
void safe(); 　//安全性算法函数
void bank（）; //银行家算法函数
void show （）; 　//输出当前资源分配情况

4．主函数main()
int main(）
｛
cout<〈…… //显示程序开始提示信息
chushihua（）； //初始化函数调用
cout〈〈endl<<endl；
showdata()； //输出初始化后的状态
//===判断当前状态的安全性===
safe（); //安全性算法函数调用
if (l〈n）｛
cout<<”\n当前状态不安全，无法申请，程序退出！!！!!”<〈endl;
cout〈〈endl；
system("pause”）；
sign(); //调用签名函数
return 0; // break；
}
else{
int i； //局部变量
l=0；
cout<<”\n安全的状态!!!"<〈endl；
cout<<”安全序列为： ”;
cout〈<endl〈〈”进程"<〈”（"〈〈p[0]<<”)"; //输出安全序列，考虑显示格式，先输出第一个
for （i=1； i〈n; i++)｛
cout<<"==>〉”<<”进程”〈〈”（”〈〈p[i］<<”)"；
｝
for （i=0; i<n； i++） Finish[i］=0; //所有进程置为未分配状态
cout〈<endl<<endl；
}
bank()； //银行家算法函数调用
return 0；
｝

5. 操作系统银行家算法流程图：
初始化函数chushihua()开始

AVAILABLE[[i]-=REQUEST[i];
ALLOCATION[i]+=REQUEST[i];
NEED[i]-=REQUEST[i];

输入进程的数量

输入资源种类数

输入个资源当前可用资源数

输入各进程当前已分配的资源数

输入各进程对各类资源的最大需求

输出提示：输入有误，请重新输入

初始化函数chushihua()结束，银行家函数 Bank()

提出请求REQUEST[i]

Error;
REQUEST[i]<=NEED[i]

REQUEST[i]<=AVAILABLE[[i]

Error;

Safe();
输出提示：你的请求被拒！

AVAILABLE[i]-=REQUEST[i]；ALLOCATION[i]-=REQUEST[i];
NEED[i]+=REQUEST[i]；
输出提示：同意分配请求

是否进行再次分配

退出程序，银行家算法Bank()结束;

安全性算法Safe()开始

Work=AVAILABLE;
FINISH=false；

NEED[i]<=Work&&FINISH[i]=false;

Work+=ALLOCATION[i];
FINISH[i]=ture;

所有进程的FINISH=ture；
输出提示：系统是不安全的

安全，输出安全序列
Return ture；

安全算法safe()结束

2. 源程序代码:
#include 〈iostream.h〉
#include <vector〉
#include 〈iomanip>
using namespace std；
＃define TRUE 1 //定义 TRUE =1
#define FALSE 0 //定义 FLASE=0
void bank(vector〈int>,vector〈vector<int〉 >,vector<vector<int〉 〉，int ,int )； //声明bank（应行家算法）
int safe(vector〈int> Available,vector<vector<int〉 > Need,vector〈vector<int〉 > Allocation,int n,int m);//声明safe(）安全性算法
void init(）;
/*＊**＊＊＊**＊＊*****＊***＊*＊**＊*****＊＊＊***主函数main（）*＊*****＊*＊＊＊＊＊＊*＊***＊＊**＊＊＊＊＊**＊＊*＊**＊*＊＊**＊＊*＊*＊**＊*＊＊＊＊＊＊＊*＊/
void main()
{
init(）;
int safe（vector〈int〉 Available，vector<vector<int> > Need，vector〈vector〈int> 〉 Allocation,int n，int m）；
}
/***＊***＊＊＊＊*＊****＊＊**＊*＊＊＊＊＊*＊＊***＊*＊＊初始化函数init(）**＊＊＊＊*＊*＊＊＊*******＊*＊＊＊*＊＊**＊*＊****＊＊**＊*＊＊*＊******＊＊*＊＊/
void init（）
｛
int m； //m资源类数
int n； //进程数
cout<<”输入资源类数”<〈endl;
cin〉>m；
vector〈int> Available（m）; //动态申请数组Available可用资源向量
cout〈〈”输入各类资源总数："〈<endl;
/＊*＊**＊***＊*＊＊*＊*＊＊*＊*＊*＊＊**＊＊***＊*＊*＊**＊*＊**＊*****＊＊＊＊＊***＊＊*＊**＊*＊*＊＊＊＊/
/* 下面的被刚掉的为在DOS下输入资源向量＊/
/*未被刚掉的是从Available。txt文件中读入数据*/
/＊＊*＊*＊**＊*＊＊＊＊＊＊＊*****＊＊＊＊*****＊*******＊＊***＊＊＊**＊＊*＊＊＊＊＊＊＊****＊＊*＊*＊**＊/
/*/
for （int i=0;i〈m;i++）
｛
cout〈<”输入R"〈<i〈<”类资源总数："；
cin〉〉Available［i]；
}
//*/
FILE *fp；
fp=fopen(”Available。txt”，"r+")；
cout<〈”从Available.txt文件中读入数据，并输出”<〈endl;
for(int i=0；i<m;i++）
｛
fscanf(fp,”％d",&Available[i])；
cout<<Available[i]<<’\t’;
｝
fclose（fp);
cout<<”\n输入进程数”〈〈endl；
cin>〉n；
vector<vector〈int〉 〉 Max(n， vector<int〉（m））;
/*********＊**＊＊＊*＊＊*＊＊＊*＊＊***＊**＊＊*＊＊＊＊**＊＊＊***＊*＊＊*＊＊*＊*＊****＊＊＊*＊*＊**＊*/
/＊ 下面的被刚掉的为在DOS下输入资源向量*/
/＊未被刚掉的是从Max。txt文件中读入数据*/
/＊**＊*＊＊*＊*＊＊**＊＊＊*＊＊＊*＊＊*＊*＊＊＊*＊＊*＊*＊*＊＊*＊***＊＊＊*＊*＊＊＊＊*＊＊**＊*＊＊＊*＊***＊＊/
/*
for （ i=0；i<n;i++）
｛
cout<<”输入进程”〈<i<〈"的最大需求向量”；
for （int j=0；j〈m；j++）
{
cout<<" 输入需要R”<<j<<"类资源的最大数目”;
cin>>Max［i］[j];
while (Max［i][j]>Available[j］）
{
cout<〈j〈〈"类资源最大需求超过该类资源总量，重新输入";
cin>〉Max[i］［j］；
｝
}
｝//*/
fp=fopen（"Max。txt","r+");
cout<<”从Max。txt文件中读入数据，并输出”〈<endl；
for（i=0；i〈n;i++）
{
for （int j=0；j〈m；j++）
｛
fscanf（fp,”％d",＆Max[i］[j]）;
cout〈〈Max[i］[j］〈〈” ”;
｝
cout<〈endl;
｝
fclose（fp)；
cout〈〈”输入已分配的Allocation”〈<endl;
vector<vector〈int〉 〉 Allocation（n, vector〈int〉(m）)；
vector<vector<int> > Need(n, vector<int〉(m))；
/＊*＊＊*＊***＊*＊*＊＊＊*＊＊＊＊*****＊*****＊*＊＊＊＊＊＊＊＊*＊＊＊＊**＊＊*＊*＊＊***＊*＊＊＊**＊*＊*＊*/
/＊ 下面的被刚掉的为在DOS下输入资源向量*/
/＊未被刚掉的是从Allocation。txt文件中读入数据*/
/＊＊＊**＊＊＊*＊****＊****＊**＊******＊*＊＊＊***＊*＊*＊＊*＊＊*＊＊**＊＊＊**＊＊＊****＊****＊***/
/*
for （ i=0；i〈n；i++）
｛
cout<<"输入为进程"<〈i<<”的分配向量";
for (int j=0;j<m；j++）
｛
cout〈〈" 输入分配R"<<j<<”类资源的数目";
cin>>Allocation［i]［j］；
while（Allocation［i]［j]>Max[i]［j］)
｛
cout<〈j+1〈〈”类资源最大需求超过该类需求资源总量，重新输入”；
cin〉〉Allocation[i][j］；
｝
Need[i］[j]=Max［i］［j]—Allocation[i］[j］;
Available[j］ =Available［j]—Allocation[i]［j];
｝
｝//*/
fp=fopen(”Allocation。txt”,"r+”）；
cout<〈"Allocation。txt从文件中读入数据，并输出”<<endl;

for（i=0;i〈n；i++)
｛
for (int j=0；j<m;j++)
{
fscanf(fp,"%d”，＆Allocation［i][j］）；
Need［i］［j]=Max［i］［j］-Allocation［i］［j］; //在初始化Max时，同时初始化Need数组
Available［j] =Available［j］—Allocation[i］［j]; //在初始化Max时,同时修改Available数组
cout〈〈Allocation[i］[j]〈〈’ ’；
}
cout〈〈endl;

｝
fclose(fp）；
int safe(vector〈int〉 Available，vector<vector〈int〉 〉 Need,vector<vector<int〉 〉 Allocation,int n,int m);
cout<〈"此状态安全!”<<endl；

bank(Available,Need,Allocation,n,m）;//调用银行家算法bank(）函数
}

/＊**＊＊＊＊＊*＊＊＊***＊＊＊＊＊*＊＊**＊＊＊*＊***＊＊*＊＊银行家算法bank（）函数*＊**＊***＊******＊*＊*＊＊**＊*＊*＊*＊*＊＊＊＊*＊*＊＊*＊＊***＊＊＊*＊＊****＊/
void bank(vector〈int> Available，vector<vector<int> > Need，vector<vector〈int〉 > Allocation，int n,int m）
{
vector<int> Request(m）;
int all=0;
//定义变量all,如果all==0,表示进程已经运行完，如果all>=1，表示还有进程没有运行完
for （int i=0；i<n；i++)
for（int j=0;j〈m；j++）
all +=Need[i］［j］；
if （0==all）
{
cout〈〈"所有进程已经运行完，结束"<〈endl；
exit（0）；
}
int jc;//任选一个进程
char again；
all=0;//重新初始化all，
while (1）
｛
while (all==0）
{
all=0;
//如果all==0，表示进程已经运行完，如果all>=1,表示还有进程没有运行完
//循环直至all>0，即找到一个未运行完的进程
cout<〈”任选一个进程作为当前进程0-—"<〈n—1〈<endl;
cin>>jc；
for （int j=0;j〈m;j++）
{
all += Need［jc］[j];
｝
if (0==all）
{
cout<〈"此进程已经运行,重新输入"<<endl;
}
｝
cout<〈"输入该进程的请求向量"〈<endl；
for （i=0；i<m；i++)
｛
cin>>Request［i］；
while（Request［i]〉Need［jc］［i］｜｜Request[i］〉Available[i］）
｛

cout<〈"请求向量无法满足"<〈endl；
break;

}

}
//////////////////////////////////////////////////////////////////////////
//系统试探着把资源分配给该进程///////////////////////////////////////////
for (i=0;i〈m；i++）
｛
Available[i]=Available[i]-Request[i］;
Allocation［jc］［i]=Allocation[jc]［i］+Request[i]；
Need[jc］［i］=Need[jc］［i］—Request[i］;
}
int bb=0；
bb=safe（Available，Need，Allocation，n,m)；//调用安全性算法，判断此次资源分配后，系统是否处安全状态
if (1==bb)
｛
cout〈<"系统成功分配资源"〈〈endl;
｝
else
{
cout〈<”系统未能成分配资源，收回预分配资源"<<endl；
for (i=0;i<m；i++）
{
Available[i]=Available[i］+Request[i］；
Allocation[jc］［i]=Allocation［jc][i］—Request[i］;
Need［jc］[i]=Need[jc]［i］+Request［i];
}
}
cout〈〈"您还想再次请求分配吗？是请按y/Y，否请按其它键"<<endl；
cin>>again；
if（again=='y’||again==’Y')
｛
all=0；
continue;
}
break;
}
｝
/*＊*******＊＊*＊＊＊＊*＊＊*＊＊＊*＊＊＊*＊＊**＊＊*＊*＊安全性算法safe（）函数*＊＊*＊＊＊＊＊＊＊＊＊＊*****＊＊＊＊＊**＊＊＊＊＊*＊＊*＊＊****＊*＊＊*＊＊*＊＊*＊****/
int safe(vector〈int〉 Available，vector〈vector〈int〉 〉 Need,vector〈vector〈int〉 〉 Allocation，int n,int m）
｛
vector〈int> Work(m),Finish(n);//申请工作向量work，finish
Work=Available;
vector〈int> count（n); //记录安全序列
int len=—1; //记录安全序列的进程个数，如果len==n,即表示所有的finish【i】=true,处于安全状态
for(int i=0；i〈m；i++)Finish[i］=FALSE;
for (i=0;i<n；i++)
{
int needed=1；
for （int j=0；j<m；j++）
{
if（Need[i]［j］<=Work[j］)
{
needed=needed*TRUE;
}
else needed=needed*FALSE；
｝
if （（Finish[i］==FALSE）&&needed==1)
｛
for (j=0；j<m；j++)
｛
Work［j］=Work［j]+Allocation［i][j]；
}
Finish［i]=TRUE;
len=len+1;
count［len]=i;
i=-1;
}
｝
if （len==n-1）
｛
cout〈〈”系统是安全的”<〈endl；
cout〈〈"安全序列”〈<endl;
for （i=0;i〈=len;i++)
{
cout〈〈count［i］;
if (i！=len)
｛
cout<〈”-—>"；
}
｝
cout<<endl;
return TRUE；
}
else
｛
cout<<”系统是不安全的"<<endl; return FALSE； ｝}
运行结果：
1. 初始化结果

2. 检测系统资源分配是否安全结果：

六、课程设计的总结
操作系统的基本特征是并发与共享。系统允许多个进程并发执行,并且共享系统的软、硬件资源。为了最大限度的利用计算机系统的资源，操作系统应采用动态分配的策略，但是这样就容易因资源不足，分配不当而引起“死锁”。而我本次课程设计就是得用银行家算法来避免“死锁”。银行家算法就是一个分配资源的过程，使分配的序列不会产生死锁。此算法的中心思想是：按该法分配资源时，每次分配后总存在着一个进程，如果让它单独运行下去,必然可以获得它所需要的全部资源,也就是说，它能结束，而它结束后可以归还这类资源以满足其他申请者的需要.
本次程序就是按照上面的思路展开的。但是因为时间上的仓促,本课程设计的存在着以下不足：一、不能实现并发操作,即当总资源同时满足几个进程所需要的资源数时，这些进程不能同时进行，只能一一按进程顺序执行。二、扫描进程顺序单一，只能按进程到来的顺序（即编号）来扫描，从而产生的安全顺序只能是在这个顺序的基础上产生的,而其实安全顺序是有多个的。三、对进程数和资源数进行的数量进行了限制，都只能最多有十个。四、运行程序后，界面较差，进程数，所需要资源数，已分配资源数，能用资源数，不能一目了然。
这次课程设计时间上虽说仓促点，但是我依然学到了很多的实用性知识。除了更深的了解这个算法，而且对C语言进行了复习，而且其过程中有很多的知识点都不记得了，所以在此感谢在此过程中帮助过我的老师和同学。
最后的感悟就是：只要你亲自动手，你就能学到知识.
再次感谢帮助过我的老师和同学！