操作系统原理与linux银行家算法实验报告.docx

操作系统原理与linux银行家算法实验报告.docx

《操作系统原理与linux银行家算法实验报告.docx》由会员分享，可在线阅读，更多相关《操作系统原理与linux银行家算法实验报告.docx（12页珍藏版）》请在冰豆网上搜索。

操作系统原理与linux银行家算法实验报告

成绩

评阅人

评阅日期

计算机科学与技术系

实验报告

课程名称：

操作系统原理与linux

实验名称：

银行家算法

2011年04月6日

实验三银行家算法

一、实验目的：

（1）进一步理解利用银行家算法避免死锁的问题；

（2）在了解和掌握银行家算法的基础上，编制银行家算法通用程序，将调试结果显示在计算机屏幕上，再检测和笔算的一致性。

（3）理解和掌握安全序列、安全性算法

二、实验内容：

（1）了解和理解死锁；

（2）理解利用银行家算法避免死锁的原理；

（3）会使用某种编程语言。

三、实验作业：

一、安全状态

指系统能按照某种顺序如（称为序列为安全序列），为每个进程分配所需的资源，直至最大需求，使得每个进程都能顺利完成。

二、银行家算法

假设在进程并发执行时进程i提出请求j类资源k个后，表示为Requesti[j]=k。

系统按下述步骤进行安全检查：

（1）如果Requesti≤Needi则继续以下检查，否则显示需求申请超出最大需求值的错误。

（2）如果Requesti≤Available则继续以下检查，否则显示系统无足够资源，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等待。

三、安全性算法

（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;

Øgotostep2;

（4）如果所有进程的Finish［i］=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

【实验步骤】

参考实验步骤如下：

（1）参考图1-1所示流程图编写安全性算法。

（2）编写统一的输出格式。

每次提出申请之后输出申请成功与否的结果。

如果成功还需要输出变化前后的各种数据，并且输出安全序列。

（3）参考图1-2所示流程图编写银行家算法。

（4）编写主函数来循环调用银行家算法。

【思考题】

（1）在编程中遇到了哪些问题？

你是如何解决的？

（2）在安全性算法中，为什么不用变量Available，而又定义一个临时变量work？

四、实验代码：

//////////////////////////////////////////////////////////////////////

///////////////author：

黄秋鑫/////////////////////////////

///////////////objective：

实现银行家算法/////////////

//////////////time：

2011/4/6////////////////////////////////

//////////////////////////////////////////////////////////////////////

packagecom.mmc.hqx.os;

importjava.util.Scanner;

publicclassbacker{

privateintProcess=0;//定义最大进程数目

privateintResource=0;//定义最大资源类数

privateintAvailable[];//定义当前可用资源

privateintWork[];//定义系统可提供给进程继续运行所需的各类资源数目

privateintMAX[][];//定义进程最大资源需求

privateintAllocation[][];//定义进程当前已用资源数目

privateintneed[][];//定义进程需要资源数目

privateintRequest[][];//定义进程请求资源向量

privatebooleanfinish[];//定义进程完成标志

privateintP[];

privateScannerin=newScanner（System.in）;//定义全局输入流

//关闭输入流

publicvoidclose（）

{

in.close（）;

}

//构造函数，初始化各向量

publicbacker（）throwsException{

inti,j;

System.out.print（"请输入当前进程的个数:

"）;

Process=in.nextInt（）;

System.out.print（"请输入系统资源种类的类数:

"）;

Resource=in.nextInt（）;

//初始化各个数组

Available=newint[Resource];

Work=newint[Resource];

MAX=newint[Process][Resource];

Allocation=newint[Process][Resource];

need=newint[Process][Resource];

Request=newint[Process][Resource];

finish=newboolean[Process];

P=newint[Process];

//System.out.println（"请输入每个进程最大资源需求量,按照"+Process+"x"+Resource+"矩阵输入"）;

for（i=0;i

System.out.print（"请输入P"+（i+1）+"进程各类资源最大需求量:

"）;

for（j=0;j

MAX[i][j]=in.nextInt（）;

}

//System.out.println（"请输入每个进程已分配的各资源数,也按照"+Process+"x"+Resource+"矩阵输入"）;

for（i=0;i

System.out.print（"请输入P"+（i+1）+"进程各类资源已分配的资源数:

"）;

for（j=0;j

Allocation[i][j]=in.nextInt（）;

need[i][j]=MAX[i][j]-Allocation[i][j];

if（need[i][j]<0）{

System.out.println（"您输入的第"+（i+1）+"个进程所拥有的第"+（j+1）

+"个资源数错误,请重新输入:

"）;

j--;

continue;

}

}

}

System.out.print（"请输入系统各类资源可用的数目:

"）;

for（i=0;i

Available[i]=in.nextInt（）;

}

}

//银行家算法

publicvoidBank（）throwsException

{

intj,i;

inttempAvailable[]=newint[Resource];

inttempAllocation[]=newint[Resource];

inttempNeed[]=newint[Resource];

System.out.println（"-----------------------------------------------------------"）;

System.out.print（"请输入要申请资源的进程号（当前共有"+Process

+"个进程,如为进程P1申请，请输入1，以此类推）"）;

i=in.nextInt（）-1;

System.out.print（"请输入P"+（i+1）+"进程申请的各资源的数量"）;

for（j=0;j

Request[i][j]=in.nextInt（）;

}

for（j=0;j

if（Request[i][j]>need[i][j]）{

System.out.println（"您输入的申请的资源数超过进程的需求量!

请重新输入!

"）;

continue;

}

if（Request[i][j]>Available[j]）{

System.out.println（"您输入的申请数超过系统可用的资源数!

请重新输入!

"）;

continue;

}

}

for（j=0;j

tempAvailable[j]=Available[j];

tempAllocation[j]=Allocation[i][j];

tempNeed[j]=need[i][j];

Available[j]=Available[j]-Request[i][j];

Allocation[i][j]=Allocation[i][j]+Request[i][j];

need[i][j]=need[i][j]-Request[i][j];

}

if（Safe（））{

System.out.println（"分配给P"+i+"进程成功!

"）;

System.out.print（"分配前系统可用资源：

"）;

for（intk=0;k

System.out.print（tempAvailable[k]+""）;

System.out.print（"\n分配前进程P"+i+"各类资源已分配数量:

"）;

for（intk=0;k

System.out.print（tempAllocation[k]+""）;

System.out.print（"\n分配前进程P"+i+"各类资源需求数量:

"）;

for（intk=0;k

System.out.print（tempNeed[k]+""）;

System.out.print（"\n分配后系统可用资源：

"）;

for（intk=0;k

System.out.print（Available[k]+""）;

System.out.print（"\n分配后进程P"+i+"各类资源已分配数量:

"）;

for（intk=0;k

System.out.print（Allocation[i][k]+""）;

System.out.print（"\n分配后进程P"+i+"各类资源需求数量:

"）;

for（intk=0;k

System.out.print（need[i][k]+""）;

System.out.println（）;

}else{

System.out.println（"申请资源失败!

"）;

for（j=0;j

Available[j]=Available[j]+Request[i][j];

Allocation[i][j]=Allocation[i][j]-Request[i][j];

need[i][j]=need[i][j]+Request[i][j];

}

}

for（i=0;i

finish[i]=false;

}

}

//安全性算法

publicbooleanSafe（）{

inti,j,k,t=0;

Work=newint[Resource];

for（i=0;i

Work[i]=Available[i];

for（i=0;i

finish[i]=false;

}

for（i=0;i

if（finish[i]==true）{

continue;

}else{

for（j=0;j

if（need[i][j]>Work[j]）{

break;

}

}

if（j==Resource）{

finish[i]=true;

for（k=0;k

Work[k]+=Allocation[i][k];

}

P[t++]=i;

i=-1;

}else{

continue;

}

}

if（t==Process）{

System.out.print（"当前系统是安全的,存在一安全序列:

"）;

for（i=0;i

System.out.print（"P"+P[i]）;

if（i!

=t-1）{

System.out.print（"---"）;

}

}

System.out.println（）;

returntrue;

}

}

System.out.println（"当前系统是不安全的，不存在安全序列"）;

returnfalse;

}

publicstaticvoidmain（String[]args）{

try{

backerb=newbacker（）;

b.Safe（）;

for（inti=0;i<200;i++）

b.Bank（）;

b.close（）;

}catch（Exceptione）{

}

}

}

运行结果:

五、实验心得：

通过本次实验，加深了对银行家算法的理解，对于系统出现的死锁问题也有了更深刻的理解。

银行家算法是一种最有代表性的避免死锁的算法。

在避免死锁方法中允许进程动态地申请资源，但系统在进行资源分配之前，应先计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则等待。

为实现银行家算法，系统必须设置若干数据结构。

（1）在本次编程的过程中，遇到过不少问题，最典型的问题还是算法的实现，比如如何实现安全性算法、银行家算法。

而解决这些问题，就需要自己对各种算法的理解。

如安全性算法，根据安全性算法的理解，编写算法过程中，只要出现一安全序列，就断定该状态是安全的，而编写的过程中，只要有这思想，编写过程就简单得多了。

（2）在安全性算法中，用一个临时变量是为防止在该时刻不安全的情况下破坏数据的原值，即，如果不用临时变量work，而是直接用Available变量，那么如果该状态是不安全的话，那么进行安全性算法的时候，会对Available进行修改的，破坏了原来的数值。

当然，如果该状态是安全的话，直接用Available也是没问题的。

用work临时变量让程序更全面，更符合算法的要求。

总的来说，本次实验难度不大，编程不是重点，关键在理解算法。