编程序模拟银行家算法.docx

编程序模拟银行家算法.docx

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

编程序模拟银行家算法

理工大学华夏学院

课程设计报告书

课程名称：

操作系统原理

题目：

编程序模拟银行家算法

系名：

信息工程系

专业班级：

软件1121

姓名：

钟伟

学号：

指导教师:

永红

2014年6月13日

理工大学华夏学院信息工程系

课程设计任务书

课程名称：

操作系统原理课程设计指导教师：

永红

班级名称：

软件1121开课系、教研室：

软件与信息安全

一、课程设计目的与任务

操作系统课程设计是《操作系统原理》课程的后续实践课程，旨在通过一周的实践训练，加深学生对理论课程中操作系统概念，原理和方法的理解，加强学生综合运用操作系统原理、Linux系统、C语言程序设计技术进展实际问题处理的能力，进一步提高学生进展分析问题和解决问题的能力，包含系统分析、系统设计、系统实现和系统测试的能力。

学生将在指导教师的指导下，完成从需求分析，系统设计，编码到测试的全过程。

二、课程设计的容与根本要求

1、课程设计题目

编程序模拟银行家算法

2、课程设计容

本课程设计要求在Linux操作系统，GCC编译环境下开发。

银行家算法是防止死锁的一种重要方法，本实验要求用用c/c++语言在Linux操作系统环境下编写和调试一个简单的银行家算法程序。

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

思想：

将一定数量的资金供多个用户周转使用，当用户对资金的最大申请量不超过现存资金时可接纳一个新客户，客户可以分期借款，但借款总数不能超过最大的申请量。

银行家对客户的借款可以推迟支付，但是能够使客户在有限的时间得到借款，客户得到所有的借款后能在有限的时间归还。

用银行家算法分配资源时，测试进程对资源的最大需求量，假设现存资源能满足最大需求就满足当前进程的申请，否如此推迟分配，这样能够保证至少有一个进程可以得到所需的全部资源而执行到完毕，然后归还资源，假设OS能保证所有进程在有限的时间得到所需资源如此称系统处于安全状态。

3、设计报告撰写格式要求：

1设计题目与要求2设计思想

3系统结构4数据结构的说明和模块的算法流程图

5使用说明书〔即用户手册〕：

容包含如何登录、退出、读、写等操作说明

6运行结果和结果分析〔其中包括实验的检查结果、程序的运行情况〕

7自我评价与总结

8附录：

程序清单，注意加注释〔包括关键字、方法、变量等〕，在每个模块前加注释；

三、课程设计步骤与时间进度和场地安排

本课程设计将安排在第17周,教育技术中心。

具体安排如下：

第一天，下发任务书，学生查阅资料

第二天，系统设计和原型开发

第三，四天系统功能实现

第五天，系统调试测试打包和验收

周次

星期一

星期二

星期三

星期四

星期五

第17周

第1-8节

第1-8节

第1-8节

第1-8节

第1-8节

地点

现教241

现教241

现教241

现教241

现教241

四、课程设计考核与评分标准

课程设计考核将综合考虑学生考勤和参与度，系统设计方案正确性，系统设计和开发效果以与课程设计报告书的质量。

具体评分标准如下：

设置六个评分点

〔1〕设计方案正确，具有可行性、创新性；25分

〔2〕系统开发效果较好；25分

〔3〕态度认真、刻苦钻研、遵守纪律；10分

〔4〕设计报告规、课程设计报告质量高、参考文献充分20分

〔5〕课程设计辩论概念清晰，容正确10分

〔6〕课程设计期间的课堂考勤、答疑与统筹考虑。

10分

按上述六项分别记分后求和，总分按五级记分法记载最后成绩。

优秀〔100～90分〕，良好〔80～89分〕，中等〔70～79分〕，与格〔60～69分〕，

不与格〔0～59分〕

1设计题目与要求

编程序模拟银行家算法

本实验要求用用c/c++语言在Linux操作系统环境下编写和调试一个简单的银行家算法程序。

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

2设计思想

将一定数量的资金供多个用户周转使用，当用户对资金的最大申请量不现存资金时可接纳一个新客户，客户可以分期借款，但借款总数不能超过最大的申请量。

银行家对客户的借款可以推迟支付，但是能够使客户在有限的时间得到借款，客户得到所有的借款后能在有限的时间归还。

用银行家算法分配资源时，测试进程对资源的最大需求量，假设现存资源能满足最大需求就满足当前进程的申请，否如此推迟分配，这样能够保证至少有一个进程可以得到所需的全部资源而执行到完毕，然后归还资源，假设OS能保证所有进程在有限的时间得到所需资源如此称系统处于安全状态。

3．实验环境

系统平台：

LINUX

开发语言：

C

开发工具：

PC机一台

4数据结构的说明和模块的算法流程图

:

定义:

：

系统设计时确定资源分配算法，保证不发生死锁。

具体的做法是破坏产生死锁的四个必要条件之一

“不可剥夺〞条件

在允许进程动态申请资源前提下规定，一个进程在申请新的资源不能立即得到满足而变为等待状态之前，必须释放已占有的全部资源，假设需要再重新申请

“请求和保持〞条件

要求每个进程在运行前必须一次性申请它所要求的所有资源，且仅当该进程所要资源均可满足时才给予一次性分配

“循环等待〞条件

采用资源有序分配法：

把系统中所有资源编号，进程在申请资源时必须严格按资源编号的递增次、序进展，否如此操作系统不予分配。

安全状态：

如果存在一个由系统中所有进程构成的安全序列P1，…Pn，如此系统处于安全状态。

一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi（1≤i≤n〕，它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj（j

不安全状态:

不存在一个安全序列，不安全状态一定导致死锁。

4.3数据结构：

〔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]

4.4.1设置两个工作向量Work=AVAILABLE;FINISH

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

FINISH==false;

NEED<=Work;

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

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

Work+=ALLOCATION;

Finish=true;

GOTO2

4.4.4如所有的进程Finish=true，如此表示安全；否如此系统不安全。

5使用说明书

5.3使用命令./当前名字，来执行

6运行结果和结果分析

这次的设计数据是通过一道实际的题目来表现银行家算法防止死锁的问题，先用银行家算法给其中一个进程分配资源，看它所请求的资源是否大于它的需求量，才和系统所能给的资源相比拟.让进程形成一个安全队列,看系统是否安全.再利用安全性算法检查此时系统是否安全。

7自我评价与总结

在本次实验中我们使用了liunx变成环境，让我们更加系统深入的了解了liunx，gcc编程思路和思想，同时让我更加深刻的了解银行家算法,了解死锁的防止和预防，对操作系统对资源的申请和释放有了更加深刻的理解，同时在编程过程中积极的向教师同学请教问题与他们一起探讨在系统中存在的问题和漏洞。

深入了解了银行家算法的资源申请和资源分配的过程与原如此。

保证系统处于安全状态。

经过本周的课程设计，我对操作系统的掌握又进了一步，收获了很多知识。

，终于我了由于对c语言不够熟练，在试验过程中，进展了反复的修改和调试，解银行家算法的根本原理，并且在此次的课程设计中我又复习了一下c语言，加深了对它的了解，而且在课程设计的过程中我们同样学会了如何简单的操作与使用Linux操作系统，学习到了许多Linux操作系统中常用的一些密令。

这次的设计数据是通过一道实际的题目来表现银行家算法防止死锁的问题，先用银行家算法给其中一个进程分配资源，看它所请求的资源是否大于它的需求量，才和系统所能给的资源相比拟.让进程形成一个安全队列看系统是否安全.再利用安全性算法检查此时系统是否安全。

操作系统的根本特征是并发与共享。

系统允许多个进程并发执行，并且共享系统的软、硬件资源。

为了最大限度的利用计算机系统的资源，操作系统应采用动态分配的策略，但是这样就容易因资源不足，分配不当而引起“死锁〞。

而我本次课程设计就是得用银行家算法来防止“死锁〞。

银行家算法就是一个分配资源的过程，使分配的序列不会产生死锁。

此算法的中心思想是：

按该法分配资源时，每次分配后总存在着一个进程，如果让它单独运行下去，必然可以获得它所需要的全部资源，也就是说，它能完毕，而它完毕后可以归还这类资源以满足其他申请者的需要。

通过这次实验，我体会到银行家算法的重要性，银行家算法是防止死锁的主要方法，其思路在很多方面都非常值得我来学习借鉴。

通过这次实践，我知道，要做一个课程设计，如果知识面只是停留在书本上，是不可能把课成设计完全地做好。

在课程设计中，很多C语言的知识都忘了，每次的课程设计中都能将以前的知识顺便再复习一遍，课程设计是给了我们一个机会去动手和主动复习，同时也是提醒我们应该注重平时的积累。

从课程设计以后还是要多多的动手，在实践中体会理论知识，才能吸取经验教训。

经过这次实验训练，我对这门课程有了更好的了解。

8附录：

源程序清单

#include

#include

#include

#defineFalse0

#defineTrue1

intMax[100][100]={0};//各进程所需各类资源的最大需求

intAvaliable[100]={0};//系统可用资源

charname[100]={0};//资源的名称

intAllocation[100][100]={0};//系统已分配资源

intNeed[100][100]={0};//还需要资源

intRequest[100]={0};//请求资源向量

inttemp[100]={0};//存放安全序列

intWork[100]={0};//存放系统可提供资源

intp[100]={0};

intq[100][100]={0};

intz[100][100]={0};

intM=100;//作业的最大数为100

intN=100;//资源的最大数为100

intgg=1;

voidshowdata（）//显示资源矩阵

{

inti,j;

cout<

"<

cout<<"MaxAllocationNeedAvaliable"<

cout<<"进程名";

for（j=0;j<4;j++）{

for（i=0;i

cout<

cout<<"";

}

cout<

for（i=0;i

cout<<""<

for（j=0;j

cout<

cout<<"";

for（j=0;j

cout<

cout<<"";

for（j=0;j

cout<

if（i==0）{

cout<<"";

for（j=0;j

cout<

}

cout<

}

}

intchangdata（inti）//进展资源分配

{

intj;

for（j=0;j

Avaliable[j]=Avaliable[j]-Request[j];

//q[i][j]=Allocation[i][j];

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

//z[i][j]=Need[i][j];

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

}

return1;

}

intsafe（）//安全性算法

{

inti,d,k=0,m,h,s,apply,Finish[100]={0};

intj;

intflag=0;

for（i=0;i

Work[i]=Avaliable[i];

cout<

cout<<"WorkNeedAllocationWork+AllocationFinish"<

cout<<"进程名";

for（h=0;h<4;h++）{

for（s=0;s

cout<

cout<<"";

}

cout<

for（i=0;i

apply=0;

for（j=0;j

if（Finish[i]==False&&Need[i][j]<=Work[j]）

{

apply++;

if（apply==N）

{cout<<""<

for（d=0;d

cout<

cout<<"";

for（d=0;d

cout<

cout<<"";

for（d=0;d

cout<

cout<<"";

for（m=0;m

{

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

cout<

}//变分配数

Finish[i]=True;

temp[k]=i;

cout<<"";

cout<<"true"<<"";

cout<

i=-1;

k++;

flag++;

}

}

}

}

for（i=0;i

if（Finish[i]==False）{

for（j=0;j

Avaliable[j]=Avaliable[j]+Request[j];;

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

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

}

cout<

此时系统不分配资源！

"<

return0;

}

}

cout<

"<

cout<<"安全序列为:

";

for（i=0;i

cout<

if（i";

}

cout<

return0;

}

voidshare（）//利用银行家算法对申请资源对进展判定

{

charch;

inti=0,j=0;

ch='y';

cout<

";

cin>>i;//输入须申请的资源号

cout<

"<

for（j=0;j

{

cout<

";

cin>>Request[j];//输入需要申请的资源

}

for（j=0;j

if（Request[j]>Need[i][j]）//判断申请是否大于需求，假设大于如此出错

{

cout<

cout<<"分配不合理，不予分配！

"<

ch='n';

break;

}

else{

if（Request[j]>Avaliable[j]）//判断申请是否大于当前资源，假设大于如此

{//出错

cout<

cout<<"分配出错，不予分配!

"<

ch='n';

break;

}

}

}

if（ch=='y'）{

changdata（i）;//根据进程需求量变换资源

showdata（）;//根据进程需求量显示变换后的资源

safe（）;//根据进程需求量进展银行家算法判断

}

}

intmain（）//主函数

{

intt=1,i,j,number,choice,m,n,flag;

charming;

cout<<"*****************银行家算法的设计与实现*****************"<

cout<

";

cin>>n;

N=n;

for（i=0;i

{

cout<<"资源"<

";

cin>>ming;

name[i]=ming;

cout<<"资源的数量:

";

cin>>number;

Avaliable[i]=number;

}

cout<

cout<<"请输入作业的数量:

";

cin>>m;

M=m;

cout<

"<

for（i=0;i

for（j=0;j

cin>>Max[i][j];

do{

flag=0;

cout<

"<

for（i=0;i

for（j=0;j

cin>>Allocation[i][j];

if（Allocation[i][j]>Max[i][j]）

flag=1;

Need[i][j]=Max[i][j]-Allocation[i][j];

}

if（flag）

cout<

\n"<

}

while（flag）;

showdata（）;//显示各种资源

safe（）;//用银行家算法判定系统是否安全

while

（1）{

if（t==1）{

cout<

share（）;

t=0;}

elsebreak;

cout<

（按1键继续,按其它任意键退出）:

";

cin>>t;

cout<

}

return1;

}

设计过程中质疑〔或辩论〕记载：

1.银行家算法的主要思想是什么？

答：

一个进程进入系统时分配资源之前,判断系统是否是安全的，即看它所求

的资源是否大于它的最大需求量，假设正常,如此判断该进程所需剩余剩余量（包括本次申请）是否超出系统所掌握的剩余资源量,假设不超出,

如此分配,否如此等待。

2.银行家算法的主要问题是什么？

答：

要求每个进程必须事先知道资源的最大需求量，而且，在系统运行过程中，考查每个进程对各类资源的申请需花费较多的时间。

3.在银行家算法中各个资源存在什么关系？

答：

该进程所需要的资源数NEED[m][n]=MAX[m][n]（该进程所需要的最多的资源数）-----ALLOCATION[m][n]（该进程所占有的资源数）

指导教师评语：

签名：

2014年6月13日