银行家算法报告.docx

银行家算法报告.docx

《银行家算法报告.docx》由会员分享，可在线阅读，更多相关《银行家算法报告.docx（8页珍藏版）》请在冰豆网上搜索。

银行家算法报告

资料范本

本资料为word版本，可以直接编辑和打印，感谢您的下载

银行家算法报告

地点：

__________________

时间：

__________________

说明：

本资料适用于约定双方经过谈判，协商而共同承认，共同遵守的责任与义务，仅供参考，文档可直接下载或修改，不需要的部分可直接删除，使用时请详细阅读内容

操作系统实验报告

——银行家算法

班级：

计1009

学号：

20101221138

姓名：

******

二零一二年十二月

一、实验目的

通过一个简单的共享资源分配与银行家算法的实现，加深对其中安全性算法的了解。

二、实验内容

[问题描述]

本题主要内容是模拟实现资源分配。

银行家算法是避免死锁的一种重要方法，本实验要求用高级语言编写和调试一个简单的银行家算法程序。

加深了解有关资源申请、避免死锁等概念，并体会和了解死锁和避免死锁的具体实施方法。

通过对这个算法的设计,让学生能够对书本知识有更深的理解,在操作和其它方面有更高的提升。

[基本要求]具体用银行家算法实现资源分配。

要求如下：

（1）设计一个3个并发进程共享3类不同资源的系统，进程可动态地申请资源和释放资源，系统按各进程的申请动态地分配资源。

（2）设计用银行家算法，实现资源分配，应具有显示或打印各进程依次要求申请的资源数以及依次分配资源的情况。

（3）确定一组各进程依次申请资源数的序列，输出运行结果。

[方案设计及开发过程]

1银行家分配算法，顾名思义是来源于银行的借贷业务，一定数量的本金要应多个客户的借贷周转，为了防止银行加资金无法周转而倒闭，对每一笔贷款，必须考察其是否能限期归还。

在操作系统中研究资源分配策略时也有类似问题，系统中有限的资源要供多个进程使用，必须保证得到的资源的进程能在有限的时间内归还资源，以供其他进程使用资源。

如果资源分配不得到就会发生进程循环等待资源，每个进程都无法继续执行下去的死锁现象。

把个进程需要和已占有资源的情况记录在进程控制中，假定进程控制块PCB其中“状态”有就绪态、等待态和完成态。

当进程在处于等待态时，表示系统不能满足该进程当前的资源申请。

“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。

显然，每个进程的资源需求总量不能超过系统拥有的资源总数,银行算法进行资源分配可以避免死锁.

2.算法描述

银行家算法:

设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。

（1）如果Request[N]<=NEED[I，N]，则转

（2）；否则，出错。

（2）如果Request[N]<=AVAILABLE，则转（3）；否则，出错。

（3）系统试探分配资源，修改相关数据：

AVAILABLE=AVAILABLE-REQUEST

ALLOCATION=ALLOCATION+REQUEST

NEED=NEED-REQUEST

（4）系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。

3．安全性检查

（1）设置两个工作向量WORK=AVAILABLE；FINISH[M]=FALSE

（2）从进程集合中找到一个满足下述条件的进程，

FINISH[i]=FALSE

NEED<=WORK

如找到，执行（3）；否则，执行（4）

（3）设进程获得资源，可顺利执行，直至完成，从而释放资源。

WORK=WORK+ALLOCATION

FINISH=TRUE

GOTO2

（4）如所有的进程Finish[M]=true，则表示安全；否则系统不安全。

3.数据结构

假设有M个进程N类资源，则有如下数据结构:

#defineW10

#defineR20

intM;//总进程数

intN;//资源种类

intALL_RESOURCE[W];//各种资源的数目总和

intMAX[W][R];//M个进程对N类资源最大资源需求量

intAVAILABLE[R];//系统可用资源数

intALLOCATION[W][R];//M个进程已经得到N类资源的资源量

intNEED[W][R];//M个进程还需要N类资源的资源量

intRequest[R];//请求资源个数

三、程序和运行情况

#include

#include

intM=3;//进程的个数

intN=3;//资源的种类

intall_resource[R]={15,20,25};//3类资源的总量

intmax[3][3]={{10,10,10},{8,8,8},{5,5,5}};//进程的最大需求量

intallocation[3][3]={{5,5,7},{6,6,6},{1,2,4}};//进程已分配的资源量

intneed[3][3]={{5,5,3},{2,2,2},{4,3,1}};//进程的需求量

intavailable[3]={3,7,8};//还可分配的资源

intrequest[3];//进程的请求量

intk;//将输入请求的进程名赋予k

inttemp[3];//存放安全序列

//函数声明

voidintput（）;

voidfirst（）;

intinrequest（）;

voidsafe（）;

voidsafe（）//安全性算法

{

inti=0,p=0;

intapply;

inth;

intFinish[3]={0};//进程的状态标志

intflag=0;//记录进程的标记位是否可以全部转为true

intwork[3];

for（intq=0;q<3;q++）//将可用资源赋给work数组

{

work[q]=available[q];

}

while（i

{

apply=0;

for（intj=0;j<3;j++）

{

if（Finish[i]==0&&need[i][j]<=work[j]）//判断进程的状态，需求量和可用资源的比较

{

apply++;

}

}

if（apply==3）//若进程的三类资源都小于可用资源时

{

for（intm=0;m<3;m++）//将分配给该进程的资源回收

{

work[m]=work[m]+allocation[i][m];

}

Finish[i]=1;//将进程的状态置为1

temp[p]=i;//将进程号放入安全序列数组

i=0;

p++;//将安全序列数组的指针后移

}

else

{

i=i+1;

}

}

for（i=0;i

{

if（Finish[i]==0）//判断是否所有进程都可分配资源完成

{

flag++;

}

}

if（flag!

=0）//若不是所有进程都可完成

{

printf（"分配后系统不安全，不予分配!

\n"）;

for（i=0;i

{

available[i]=available[i]+request[i];

allocation[k][i]=allocation[k][i]-request[i];

need[k][i]=need[k][i]+request[i];

}

printf（"是否重新提出要求：

1、是2、否\n"）;

scanf（"%d",&h）;

if（h==1）

first（）;

else

exit（0）;

}

else//若是所有进程都可完成

{

printf（"系统是安全的!

\n"）;

printf（"安全序列为：

"）;

for（i=0;i

{

printf（"%d",temp[i]）;

}

printf（"已分配资源\n"）;

printf（"是否重新提出要求：

1、是2、否\n"）;

scanf（"%d",&h）;

if（h==1）

first（）;

else

exit（0）;

}

}

intinrequest（）

{

printf（"请输入提出要求的进程号和三类资源的请求量：

"）;

scanf（"%d%d%d%d",&k,&request[0],&request[1],&request[2]）;

if（k>3）

{

printf（"没有该进程！

"）;

return-1;

}

k--;

if（（request[0]<=need[k][0]）&&（request[1]<=need[k][1]）&&（request[2]<=need[k][2]））//请求量和需求量的比较

{

if（（request[0]<=available[0]）&&（request[1]<=available[1]）&&（request[2]<=available[2]））//请求量和可用资源的比较

{

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

{

available[i]=available[i]-request[i];

allocation[k][i]=allocation[k][i]+request[i];

need[k][i]=need[k][i]-request[i];

}

return1;

}

else

{

printf（"请求量大于可用资源量\n"）;

return-1;

}

}

else

{

printf（"请求量大于需求量\n"）;

return-1;

}

}

voidfirst（）

{

inta;

a=inrequest（）;

if（a==1）

{

safe（）;

}

}

voidmain（）

{

printf（"三类资源的总量为：

（%d,%d,%d）\n",all_resource[0],all_resource[1],all_resource[2]）;

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

printf（"第%d个进程三类资源的需求量为：

（%d,%d,%d）\n",i+1,need[i][0],need[i][1],need[i][2]）;

first（）;

}

运行情况如下：

先输出所有资源的总量和各个进程对资源的需求量：

当输入的资源请求量大于需求量时：

当假设分配后系统仍属于安全时：