操作系统课程设计-尹朝辉.doc

操作系统课程设计 尹朝辉

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

2

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

辽 宁 科 技 大 学
课程设计说明书

设计题目： 银行家算法
学院、系： 电信学院
专业班级: 计2011—2
学生姓名： 尹朝辉
指导教师： 柴玉梅
成 绩：

2014 年 03 月 06 日

一、设计目的
本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练，通过课程设计，更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解，加强学生的动手能力.
二、设计内容
1)概述
用C或C++语言编制银行家算法通用程序，并检测所给状态的系统安全性。
1. 算法介绍:数据结构:
1） 可利用资源向量 Available;
2） 最大需求矩阵Max;
3） 分配矩阵Allocation；
4） 需求矩阵Need
2. 功能介绍
模拟实现Dijkstra的银行家算法以避免死锁的出现，分两部分组成：
第一部分：银行家算法（扫描）;
第二部分：安全性算法。
2）设计原理
一．银行家算法的基本概念
1、死锁概念。
在多道程序系统中，虽可借助于多个进程的并发执行，来改善系统的资源利用率,提高系统的吞吐量，但可能发生一种危险━━死锁。所谓死锁(Deadlock），是指多个进程在运行中因争夺资源而造成的一种僵局（Deadly_Embrace）,当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。一组进程中，每个进程都无限等待被该组进程中另一进程所占有的资源，因而永远无法得到的资源，这种现象称为进程死锁，这一组进程就称为死锁进程。
2、关于死锁的一些结论：
Ø 参与死锁的进程最少是两个
Ø （两个以上进程才会出现死锁）
Ø 参与死锁的进程至少有两个已经占有资源
Ø 参与死锁的所有进程都在等待资源
Ø 参与死锁的进程是当前系统中所有进程的子集

注：如果死锁发生,会浪费大量系统资源，甚至导致系统崩溃。
3、资源分类。
永久性资源：
可以被多个进程多次使用(可再用资源)
l 可抢占资源
l 不可抢占资源
临时性资源：只可使用一次的资源;如信号量，中断信号，同步信号等（可消耗性资源）
　　　　　　“申请--分配——使用—-释放”模式

4、产生死锁的四个必要条件：互斥使用（资源独占）、不可强占（不可剥夺)、请求和保持（部分分配，占有申请）、循环等待。
1） 互斥使用（资源独占)
一个资源每次只能给一个进程使用.
2） 不可强占(不可剥夺)
资源申请者不能强行的从资源占有者手中夺取资源，资源只能由占有者自愿释放。
3) 请求和保持（部分分配,占有申请）
一个进程在申请新的资源的同时保持对原有资源的占有(只有这样才是动态申请，动态分配)。
4) 循环等待
存在一个进程等待队列
{P1 , P2 , … , Pn｝，
其中P1等待P2占有的资源，P2等待P3占有的资源，…，Pn等待P1占有的资源，形成一个进程等待环路.
5、死锁预防：
定义：在系统设计时确定资源分配算法，保证不发生死锁。具体的做法是破坏产生死锁的四个必要条件之一。
①破坏“不可剥夺"条件
在允许进程动态申请资源前提下规定，一个进程在申请新的资源不能立即得到满足而变为等待状态之前,必须释放已占有的全部资源，若需要再重新申请
②破坏“请求和保持”条件。
要求每个进程在运行前必须一次性申请它所要求的所有资源，且仅当该进程所要资源均可满足时才给予一次性分配。
③破坏“循环等待”条件
采用资源有序分配法:
把系统中所有资源编号，进程在申请资源时必须严格按资源编号的递增次序进行,否则操作系统不予分配.
6．安全状态与不安全状态
安全状态：
如果存在一个由系统中所有进程构成的安全序列P1，…Pn，则系统处于安全状态.一个进程序列{P1,…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n)，它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj （j < i ）当前占有资源量之和，系统处于安全状态 （安全状态一定是没有死锁发生的)
不安全状态：不存在一个安全序列，不安全状态一定导致死锁。
二．银行家算法
1、银行家算法中的数据结构
1）可利用资源向量Available
它是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源数目。其数值随该类资源的分配和回收而动态地改变。如果Available[j］=K，则表示系统中现有Rj类资源K个。
2）最大需求短阵Max
这是-个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max(i，j)＝K，表示进程i需要Rj类资源的最大数目为K.
3)分配短阵Allocation
这是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每个进程的资源数。如果Allocation(i，j）＝K，表示进程i当前已分得Rj类资源的数目为K。
4)需求矩阵Need
它是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数，如果Need[i，j]=K,则表示进程i还需要Rj类资源k个，方能完成其任务。
上述三个矩阵间存在下述关系：
Need[i,j］=Max［i,j］—Allocation[i,j]
2、银行家算法
设Requesti是进程Pi的请求向量。如果Requesti[j]＝k，表示进程只需要k个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查：
1）如果 Requesti［j］<=Need[i，j］，则转向步骤2；否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值.
2）如果Requesti[j]〈=Available[j] ，则转向步骤3；否则,表示系统中尚无足够的资源,Pi必须等待。
3)系统试探把要求的资源分配给进程Pi，并修改下面数据结构中的数值:
Available[j］：=Available［j]-Requesti[j]；
Allocation[i,j］:=Allocation［i，j]+Requesti［j］;
Need［i,j］：=Need［i，j］-Requesti[j];
4）系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全,才正式将资源分配给进程Pi，以完成本次分配；否则，将试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
3、安全性算法
系统所执行的安全性算法可描述如下：
1)设置两个向量
①、工作向量Work。它表示系统可提供给进程继续运行所需要的各类资源数目，它含有m个元素，执行安全算法开始时,Work = Available。
②、Finish。它表示系统是否有足够的资源分配给进程，使之运行完成,开始时先做Finish［i］:=false ；当有足够资源分配给进程时,令 Finish[i］:=true。
2)从进程集合中找到一个能满足下述条件的进程：
①、Finish[i］=false； ②、Need[i,j］〈=Work[j］;如找到，执行步骤（3）;否则，执行步骤（4）。
3）当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work［j］:=Work［i］+Allocation[i,j];
Finish[i]：=true;
goto step 2；
4）如果所有进程的Finish［i］:=true,则表示系统处于安全状态；否则，系统处于不安全状态。
3）详细设计及编码
1)银行家算法流程图

2)程序源代码
#include <iostream。h>
＃include <stdio.h>
＃include <stdlib。h>
#include 〈string。h〉
//定义全局变量
const int x=20，y=20； //常量，便于修改
int Available[x］； //各资源可利用的数量
int Allocation[y][y]; //各进程当前已分配的资源数量
int Max[y][y]； //各进程对各类资源的最大需求数
int Need［y]［y]； //尚需多少资源
int Request[x]; //申请多少资源
int Work[x］; //工作向量，表示系统可提供给进程继续运行所需的各类资源数量
int Finish［y]; //表示系统是否有足够的资源分配给进程,1为是
int p[y］; //存储安全序列
int i,j; //i表示进程，j表示资源
int n，m； //n为进程i的数量，m为资源j种类数
int l=0； //l用来记录有几个进程是Finish［i]=1的，当l=n是说明系统状态是安全的
int counter=0;

//函数声明
void chushihua(）; //初始化函数
void safe(）; //安全性算法
void show（）; //函数show，输出当前状态
void bank()； //银行家算法
//void jieshu（); //结束函数

void chushihua()
｛
cout〈<"输入进程的数量： ”；//从此开始输入有关数据
cin>〉n；
cout<<”输入资源种类数: ";
cin〉>m；
cout〈<endl<〈"输入各种资源当前可用的数量( ”〈<m<〈" 种)： "<<endl;
for (j=0； j〈m; j++）
｛
cout〈<”输入资源 ”〈〈j<<” 可利用的数量Available［”〈〈j〈<”］： ”；
cin>>Available［j］; //输入数字的过程。..
Work［j]=Available[j］; //初始化Work［j]，它的初始值就是当前可用的资源数
｝
cout<<endl〈〈"输入各进程当前已分配的资源数量Allocation［"<<n<<"］［"<<m〈<"］： "〈〈endl；
for (i=0； i〈n; i++）
{
for (j=0； j<m； j++)
｛
cout<<” 输入进程 ”<〈i〈〈" 当前已分配的资源 ”<<j〈<" 数量： ”;
cin〉>Allocation[i］[j］;
}
cout<<endl;
Finish[i]=0；//初始化Finish[i]
}
cout<<endl<<"输入各进程对各类资源的最大需求Max["〈〈n<〈”]["〈〈m〈〈"］： ”<<endl;
for （i=0; i〈n； i++)
{
for (j=0； j<m; j++）
｛
cout<<" 输入进程 "〈〈i〈<" 对资源 "<<j〈〈" 的最大需求数： ";
cin>〉Max[i]［j］;
if(Max[i]［j］〉=Allocation[i][j]) //若最大需求大于已分配，则计算需求量
Need［i][j] = Max［i][j］—Allocation［i］［j］；
else
Need[i][j］=0；//Max小于已分配的时候，此类资源已足够不需再申请
｝
cout<<endl；
｝
cout<〈endl<〈”初始化完成"<〈endl；
｝

//安全性算法函数
void safe(）
｛
l=0;
for (i=0； i〈n；i++）
{ //i++
if （Finish[i]==0)
｛ //逐个查找Finish[i]==0的进程 条件一
counter=0； //记数器
for (j=0; j〈m； j++)
｛
if (Work[j］>=Need［i]［j]） counter=counter+1;//可用大于需求，记数
｝
if（counter==m) //i进程的每类资源都符合Work[j］〉=Need[i][j] 条件二
{
p［l］=i； //存储安全序列
Finish[i］=1； //i进程标志为可分配
for (j=0； j<m；j++)
Work［j]=Work[j］+Allocation[i][j]； //释放资源
l=l+1; //记数，现在有L个进程是安全的，当L=N时说明满足安全序列
i= -1; //从第一个进程开始继续寻找满足条件一二的进程
}
｝
｝
}

//显示当前状态函数
void show() //函数show,输出当前资源分配情况
{
int i,j; //局部变量
int All［y]; //各种资源的总数量
cout〈<”当前的状态为："〈<endl；
cout<<”各种资源的总数量:”〈〈endl；
for （j=0；j〈m;j++）
｛
cout<〈" 资源"〈〈j〈<"： ”；
All[j］=Available[j]； //总数量=可用的+已分配的
for (i=0;i<n;i++) All[j］+=Allocation[i］[j］；
cout〈<All［j］〈<” ”；
｝
cout<〈endl<〈"当前各种资源可用的量为(available）:”<〈endl;
for (j=0;j〈m；j++)
cout<<" 资源”〈〈j<<"： ”〈<Available[j]<<" ”;
cout<〈endl〈<”各进程已经得到的资源量（allocation): ”〈<endl；

for （j=0;j〈m;j++) cout<<’\t'<〈"资源"〈〈j；
cout<〈endl;
for（i=0；i<n；i++）
{
cout〈〈"进程"〈〈i〈〈”:"；
for （j=0;j〈m；j++） cout〈〈'\t'<〈" "<<Allocation[i］［j]；
cout<<endl；
}

cout〈〈endl〈<”各进程还需要的资源量(need）:”<〈endl;
for （j=0；j〈m；j++) cout〈〈'\t’〈<”资源”<〈j;
cout〈<endl；
for（i=0;i〈n;i++)
｛
cout<<”进程”<<i<〈"：";
for (j=0;j〈m;j++） cout〈<’\t'<<" ”〈〈Need［i］[j]；
cout〈<endl;
｝

}
//银行家算法函数
void bank（）
｛
cout〈〈endl〈〈"进程申请分配资源：”<<endl;
int k=0； //用于输入进程编号
bool r=false; // 初值为假,输入Y继续申请则置为真
do｛//输入请求
cout<〈"输入申请资源的进程（0—”<<n-1<<"）： ”;
cin>〉k；
cout〈<endl；
while（k>n-1） //输入错误处理
{
cout〈〈endl〈<"输入错误，重新输入：”〈〈endl;
cout<<endl〈〈”输入申请资源的进程（0-—"<〈n-1〈<”）: ";
cin〉〉k;
cout<〈endl;
｝
cout<<endl<〈”输入该进程申请各类资源的数量: ”〈<endl；
for (j=0； j〈m； j++）
{
do｛ //do……while 循环判断申请输入的情况
cout<<"进程 ”<〈k<〈" 申请资源［"〈〈j<〈"］的数量：";
cin>〉Request［j］；
cout<〈endl;
if（Request［j］〉Need[k］［j]）
｛ //申请大于需求量时出错，提示重新输入（贷款数目不允许超过需求数目)
cout<〈"申请大于需要量!”〈〈endl；
cout<〈”申请的资源”<<j〈<”的数量为"〈<Request［j]<〈”，大于 进程”〈<k〈<"对该资源需求量"<〈Need［k］[j］<〈"."〈〈endl;
cout<<”重新输入!”〈〈endl;
}
else //先判断是否申请大于需求量，再判断是否申请大于可利用量
if（Request［j］>Available［j])
｛ //申请大于可利用量， 应该阻塞等待？…… ？？？
cout〈<”\n没有那么多资源，目前可利用资源”〈<j〈<"数量为"〈〈Available［j]<〈”,本次申请不成功，进程等待！”<〈endl；
Finish[k］=0； //该进程等待
goto ppp； //goto语句 跳转，结束本次申请
}
｝while(Request［j］>Need［k]［j］); //Request[j］>Available[j]｜｜
｝
//改变Avilable、Allocation、Need的值
for (j=0; j〈m; j++)
{
Available[j] = Available[j]-Request[j];
Allocation［k］［j］ = Allocation［k］[j]+Request[j］；
Need[k］[j] = Need[k][j]-Request[j]；
Work[j] = Available[j］;
}
//判断当前状态的安全性
safe()； //调用安全性算法函数
if (l<n)
{
l=0；
cout〈〈”\n试分配后，状态不安全,所以不予分配！恢复原状态”〈〈endl；
//恢复数据
for (j=0； j〈m; j++）
｛
Available[j] = Available[j]+Request［j］；
Allocation[k][j］ = Allocation［k］［j]—Request［j];
Need［k］[j］ = Need[k]［j]+Request［j]；
Work[j］ = Available[j]；
}
for （i=0; i〈n; i++）
Finish[i]=0; //进程置为未分配状态
}
else
｛
l=0；
cout<〈"\n申请资源成功！！!”〈〈endl；
for(j=0；j<m；j++）
｛
if(Need[k］［j]==0）;
else
｛ //有一种资源还没全部申请到，则该进程不可执行，不能释放拥有的资源
l=1; //置l为1，作为判断标志
break；
｝
}
if(l！=1）
{ //进程可以执行，则释放该进程的所有资源
for （j=0；j〈m;j++)
{
Available[j]=Available[j]+Allocation[k][j］；
Allocation［k]［j］=0;
}
cout<<”该进程已得到所有需求资源,执行后将释放其所有拥有资源!"〈<endl;
｝
l=0； //归零
cout〈<”\n安全的状态！”〈<endl;
cout〈〈"安全序列为: "；
cout〈<endl〈<"进程"<<”("<〈p［0]〈<”）”； //输出安全序列，考虑显示格式，先输出第一个
Finish［0］=0;
for （i=1; i<n； i++)
｛
cout<<"==〉〉"<〈"进程"〈〈”("<<p［i］<<”)";
Finish［i］=0; //所有进程置为未分配状态
｝
cout〈〈endl〈<endl；
}
show(); //显示当前状态
ppp: //申请大于可利用量, 应该阻塞等待,结束本次资源申请，GOTO 语句跳转至此
cout〈<endl<<”是否继续申请资源(y/n) ？";
char＊ b=new char； //输入y/n，判断是否继续申请 <<endl
cin>>b；
cout<〈endl；
cout〈〈”--—-—-————-——--—-—-——-—-—----————-—--——--—-”<<endl〈<endl；
cout〈<endl;
if（＊b==’y'||*b==’Y’) r=true;
else
//{
r=false; //输入非 Y 则令 R =false
// jieshu（）； //调用结束函数
//}
｝ while (r==true);
｝
//结束函数
//void jieshu(）
//{
// cout〈〈endl〈〈endl；
// cout〈〈”\t\t 演示计算完毕"<<endl；
// cout〈<endl<〈endl；
//}

//主函数
int main（)
{
cout〈〈endl〈〈endl〈<"\t\t\t\t模拟银行家算法"〈<endl〈〈endl;
chushihua()； //初始化函数调用
cout〈〈endl；
show（）; //输出当前状态
safe(); //判断当前状态的安全性
if (l<n) //l在safe中是用来记录安全的进程的个数的
｛
cout〈〈"\n当前状态不安全，拒绝申请！"〈<endl;
cout〈〈endl;
return 0；
}
else
{
int i; //局部变量
l=0；
cout<〈endl<〈”\n当前的状态是安全的!安全序列为:”〈〈endl；
cout<<"进程”<〈"（”〈<p[0]<<”）"; //输出安全序列
for （i=1; i<n; i++） cout〈〈"—〉〉”<<”进程”<〈”（"〈<p[i]〈<")"；
for （i=0； i<n； i++） Finish［i]=0； //所有进程置为未分配状态
cout〈〈endl;
}
bank(）； //调用银行家算法函数
cout〈〈”\t\t 演示计算完毕"〈〈endl;
return 0；
｝
4）运行结果分析
1．示例数据
进程数量：5
资源种类3
资源情况
进程
Max
Allocation
Need
Available
A B C
A B C
A B C
A B C
P0
7 5 3
0 1 0
7 4 3
3 3 2
(2 3 0）
P1
3 2 2
2 0 0
（3 0 2)
1 2 2
(0 2 0)
P2
9 0 2
3 0 2
6 0 0
P3
2 2 2
2 1 1
0 1 1
P4
4 3 3
0 0 2
4 3 1
2。测试结果（以上表中数据为列）
截图如下：

5)设计小结
这次我做的课题是“银行家算法的模拟实现”，通过这次的课程设计,我不仅拓宽了自己的知识面，还在实践过程中巩固和加深了自己所学的理论知识，使自己的技术素质和实践能力有了进一步的提高，同时我的专业水平也有了很大的进步。
同时，在软件开发方面也累积了不少经验,对操作系统的知识重要性的认识更深了。通过设计过程的锻炼，自己分析问题和解决问题的能力都得到了锻炼和提高,完善了自己的知识结构,加深了对所学知识的理解。
通过几天努力，这次课程设计圆满的结束了，在这个过程中,我学到了很多的知识，在以后的学习中,我会更加努力的学好专业知识，并将所学知识用于实践当中去，以便牢固掌握知识.
6)参考文献
［1]计算机操作系统(第3版)，汤小丹,西安电子科技大学出版社，2007年7月
[2］Visual C++面向对象编程教程（第二版）,王育坚，清华大学出版社，2007年10月）

17