首页 > 领导讲话 > 党务讲话 / 正文
操作系统课程设计银行家算法的模拟实现
2020-12-04 09:50:32 ℃
操作系统
课程设计报告
专业 计算机科学与技术 学生姓名
班级
学号
指导教师
完成日期
信息工程学院 题目:
银行家算法的模拟实现
一、设计目的 本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练,通过课程设计,更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。
二、设计内容 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,则表示系统处于安全状态;否则,系统处于不安全状态。
三.银行家算法之例 假定系统中有五个进程:{P0,P1,P2,P3,P4}和三种类型的资源{A,B,C},每一种资源的数量分别为10、5、7,在T0时刻的资源分配情况如图1所示。
资源情况 进程 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 图1 T0时刻的资源分配表 (1)T0时刻的安全性:利用安全性算法对T0时刻的资源分配情况进行分析(如图2)可知,在T0时刻存在着一个安全序列{P1,P3,P4,P2,P0},故系统是安全的。
资源情况 进程 Work Need Allocation Work+Allocation Finish A
B C A
B C A
B
C A
B
C P1 3
3 2 1
2 2 2
0
0 5
3
2 true true true true true P3 5
3 2 0
1 1 2
1
1 7
4
3 P4 7
4 3 4
3 1 0
0
2 7
4
5 P2 7
4 5 6
0 0 3
0
2 10
4
7 P0 10 4 7 7
4 3 0
1
0 10
5
7 图2 T0时刻的安全序列 (2)P1请求资源:P1发出请求向量Request1(1,0,2),系统按银行家算法进行检查:
①Request1(1,0,2)<=Need1(1,2,2)
②Request1(1,0,2)<=Available1(3,3,2)
③系统先假定可为P1分配资源,并修改Available,Allocation1和Need1向量,由此形成资源变化情况如图1中的圆括号所示。
④再利用安全性算法检查此时系统是否安全。如图3所示。
资源情况 进程 Work Need Allocation Work+Allocation Finish A
B C A
B C A
B
C A
B
C P1 2
3 0 0
2 0 3
0
2 5
3
2 true true true true true P3 5
3 2 0
1 1 2
1
1 7
4
3 P4 7
4 3 4
3 1 0
0
2 7
4
5 P0 7
4 5 7
4 3 0
1
0 7
5
5 P2 7
5 5 6
0 0 3
0
2 10
5
7 图3 P1申请资源时的安全性检查 由所进行的安全性检查得知,可以找到一个安全序列{P1,P3,P4,P2,P0}。因此系统是安全的,可以立即将P1所申请的资源分配给它。
(3)P4请求资源:P4发出请求向量Request4(3,3,0),系统按银行家算法进行检查:
①Request4(3,3,0)≤Need4(4,3,1);
②Request4(3,3,0)不小于等于Available(2,3,0),让P4等待。
(4)P0请求资源:P0发出请求向量Request0(0,2,0),系统按银行家算法进行检查。
①Request0(0,2,0) ≤Need0(7,4,3);
②Request0(0,2,0) ≤Available(2,3,0);
③系统暂时先假定可为P0分配资源,并修改有关数据,如图4所示。
资源情况 进程 Allocation Need Available A
B
C A
B
C A
B
C P0 0
3
0 7
3
2 2
1
0 P1 3
0
2 0
2
0 P2 3
0
2 6
0
0 P3 2
1
1 0
1
1 P4 0
0
2 4
3
2 图4 为P0分配资源后的有关资源数据 (5)进行安全性检查:可用资源Available(2,1,0)已不能满足任何进程的需要,故系统进入不安全状态,此时系统不分配资源。
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月)
猜你喜欢
- 2024-01-13 2024乡镇优秀组织委员优秀党务工作者先进事迹材料
- 2024-01-08 2024年度优秀党务工作者事迹材料(范文推荐)
- 2024-01-07 (3合集)关于党务论谈材料汇编
- 2023-12-27 2024年度优秀党务工作者事迹材料(范文推荐)
- 2023-09-26 2023关于党务干部培训方案6篇
- 2023-07-15 党建党务知识测试题(范文推荐)
- 2023-07-15 市文化和旅游局优秀党务工作者先进事迹材料
- 2023-07-14 2023年某局优秀党务工作者简要事迹材料
- 2023-07-05 优秀党务工作者先进事迹材料()
- 2023-07-02 2023年全市公安机关党务干部培训会议动员讲话
- 搜索
-
- 关于进一步规范干部借调工作的实施办法 04-08
- 2021国家开放大学电大本科《国际私法》 11-03
- 组织生活会专题学习心得体会 09-07
- “党建+安全”主题党日活动方案 03-31
- 镇退役军人服务站情况汇报 11-04
- 纪委监委意识形态工作经验交流:发挥专 05-12
- 看《即将到来的对华战争》观后感 07-24
- 劳务派遣人员薪酬管理办法 04-07
- 民族团结进步创建工作情况总结 04-10
- 2020年全面从严治党履行“一岗双责”情 07-09
- 11-25国庆70周年庆典晚会 庆典晚会串词
- 11-25办公室礼仪的十大原则 浅谈办公室的电话礼仪
- 01-17用心灵轻轻地歌唱_心灵的歌唱
- 01-17也许你不是我一生的唯一|也许不是我
- 01-17爱了,请珍惜;不爱,趁早放手|爱就珍惜不爱就放手
- 01-17岁月带走的是记忆,但回忆会越来越清晰|有趣又有深意的句子
- 01-17曾经的美好只是曾经,我只想珍惜身边的人|我只想珍惜你
- 01-18从容不惊 [学会笑眼去看世界,不惊不乍,淡定从容]
- 02-03当代大学生学习态度调查报告
- 02-03常用护患英语会话
- 标签列表