课程设计模板110

课程设计（大作业）报告

课程名称： 操作系统 设计题目： 银行家算法模拟 院 系： 信息技术学院 班 级： 2011级计科1班 设 计 者： 李智锟 学 号： 201111010112 指导教师： 段玻 设计时间： 2013-12(23——27号）

昆

明

学

院

昆明学院课程设计（大作业）任务书

姓 名：李智锟 专 业：计算机科学与技术 任务起止日期：2013.12.23——2013.12.27 课程设计题目： 银行家算法 课程设计要求及任务描述： 1。查资料了解题目，弄明白要做些什么。 2.。绘制系统流程图，交予老师检查。 3.。查资料准备写程序。 4.。编写程序并调试运行。 5。.修改程序中出现的错误和警告。 6.。进行答辩。 7。归纳总结，整理资料。 8.。写实验大报告。 9.提交报告。 工作计划及安排： 2013.12.23：熟悉题目，看任务要求。 2013.12.24：画流程图，并对流程图不足的地方进行修改。 2013.12.25到26号：写程序并运行程序。 2013.12.27：递交大作业报告。 指导教师签字 年 月 日 院（系）：信息技术学院 学 号：201111010112 课程设计（大作业）成绩 学号：201111010112 课程设计题目：李智锟 完成情况总结： 在这次实验里边我遇到了许多问题，分别有 1.对数据结构中的各个矩阵分不太清楚。解决办法：通过看老师给的PPT解决。 2.程序问题：在百度和同学的帮助下解决。 3.程序运行遇到的问题：在同学和老师的帮助下完成. 姓名：李智锟 指导教师：段玻 指导教师评语： 成绩： 填表时间：2013.12.27 指导教师签名： 课程设计（大作业）报告

一、题目分析

1、始化这组进程的最大资源请求和一次申请的资源序列。把各进程已占用和需求资源情况记录在进程控制块中。假定进程控制块的内容包括：进程名，状态，当前申请量，资源需求总量，已占资源量，能执行完标志。其中，进程的状态有：就绪，等待和完成。当系统不能满足进程的资源请求时，进程出于等待状态。资源需求总量表示进程运行过程中对资源的总的需求量。已占资源量表示进程目前已经得到但还为归还的资源量。因此，进程在以后还需要的剩余资源量等于资源需要总量减去已占资源量。陷入每个进程的资源需求总量不应超过系统拥有的资源总量。

2、银行家算法分配资源的原则是：当某个进程提出资源请求时，假定先分配资源给它，然后查找各进程的剩余请求，检查系统的剩余资源量是否由于进程的分配而导致系统死锁。若能，则让进程等待，否则，让进程的假分配变为真分配。

A) 查找各进程的剩余请求，检查系统的剩余资源量是否能满足其中一进程，如果能，则转B）。

B）将资源分配给所选的进程，这样，该进程已获得资源最大请求，最终能运行完成。标记这个进程为终止进程，并将其占有的全部资源归还给系统。

重复第A)步和B)步，直到所有进程都标记为终止进程，或知道一个死锁发生。若所有进程都标记为终止进程，则系统的初始状态是安全的，否则为不安全的。若安全，则正式将资源分配给它，否则，假定的分配作废，让其等待。

二、程序设计 1． 数据结构设计

假设有m个进程，则有如下数据结构: #define w 50 //宏定义 #define r 50 //宏定义 int m; //总进程数

int all[w];//各种资源的数目总和

int max[w][r]; //m个进程最大资源需求量 int available[r]; //系统可用资源数

int allocation[w][r]; //m个进程已经得到资源的资源量 int need[w][r]; //m个进程还需要资源的资源量 int request[r]; //请求资源个数

2． 函数设计

设Request[n]，是进程的请求向量，如果Request[n]=m，则表示该进程需要m个资源。当该进程发出资源请求后，系统按下述步骤进行检查： (1)如果Request[n]《=Need[i，n]，便转向步骤（2）；否则认为出错，因为它所需要的资源数已经超过它所宣布的最大值。

(2)如果Request[n]>Available，则进程i进入等待资源状态，返回。 (3)假设进程i的申请已获批准，于是修改下面数据结构中的数值： Available=Available-Request Allocation=Allocation+Request Need=Need-Request

(4)系统执行安全性检查，如安全，则分配成立；否则恢复原来的资源分配状态，系统恢复原状，进程等待。

程序

void bank() //银行家算法 {

int i=0,j=0; char flag='Y';

while(flag=='Y'||flag=='y') {

i=-1;

while(i<0||i>=m) {

cout<<\请输入需申请资源的进程号（从0到\）:\ cin>>i;

if(i<0||i>=m)cout<<\该进程号不存在，请重新输入!\ }

cout<<\请输入进程\申请的资源数:\ for (j=0;j<1;j++) {

cout<<\ cin>>request[j];

if(request[j]>need[i][j]) //若请求的资源数大于进程还需要i类资源的资源量j {

cout<<\进程\申请的资源数大于进程\还需要资源的资源量!\ cout<<\申请不合理，请重新选择!\ flag='1'; break; } else {

if(request[j]>available[j]) //若请求的资源数大于可用资源数 {

cout<<\进程\申请的资源数大于系统可用资源的资源量!\ cout<<\申请不合理!请重新选择!\ flag='1'; break; } } }

if(flag=='Y'||flag=='y') {

change(i); //调用change(i)函数，改变资源数 if(chkerr(i)) //若系统安全 {

rstore(i); //调用rstore(i)函数，恢复资源数 show(); //输出资源分配情况 }

else //若系统不安全 show(); //输出资源分配情况 }

else //若flag=N||flag=n show(); cout<

cout<<\是否继续(Y/N): \ cin>>flag; } }

3． 流程图

4. 代码

#include //本实验中使用到的库函数 #include #include

int max[5][3]; //开始定义银行家算法中需要用到的数据 int allocation[5][3]; int need[5][3];

int available[3]; int request[5][3]; char *finish[5]; int safe[5]; int n,i,m; int k=0; int j=0; int work[3]; int works[5][3];

void line() //美化程序，使程序运行时更加明朗美观 { }

void start() //表示银行家算法开始 {

line();

printf(\ 银行家算法开始\\n\

printf(\ ——Designed by li zhi printf(\

kun\\n\ }

void end() //表示银行家算法结束 { }

line();

printf(\ 银行家算法结束，谢谢使用\\n\line(); line();

void input() //输入银行家算法起始各项数据 { }

void output() //输出系统现有资源情况 {

printf(\line();

printf(\资源情况 Max Allocation Need Available\\n\printf(\进程 A B C A B C A B C A B C\\n\line();

for(n=0;n<5;n++) {

for (n=0;n<5;n++) { }

printf(\请输入进程P%d的相关信息：\\n\printf(\for (m=0;m<3;m++)

scanf(\

printf(\for (m=0;m<3;m++)

scanf(\

for (m=0;m<3;m++)

need[n][m]=max[n][m]-allocation[n][m];

printf(\请输入系统可利用资源数Available:\for (m=0;m<3;m++)

scanf(\

x[n][2],allocation[n][0],allocation[n][1],allocation[n][2],need[n][0],need[n][1],need[n][2]); }

void change() //当Request[i,j]<=Available[j]时，系统把资源分配给进程P[i]，Available[j]和Need[i,j]发生改变 { }

void outputsafe() //输出安全序列的资源分配表 {

printf(\该安全序列的资源分配图如下：\\n\line();

printf(\资源情况 Work Need Allocation Work+Allocation for (m=0;m<3;m++) { }

available[m]-=request[i][m]; allocation[i][m]+=request[i][m]; need[i][m]-=request[i][m]; } line();

if (n==0)

printf(\

else

printf(\

Finish\\n\

printf(\进程 A B C A B C A B C A B C\\n\line();

for(n=0;n<5;n++)

printf(\

n],works[safe[n]][0],works[safe[n]][1],works[safe[n]][2],need[safe[n]][0],need[safe[n]][1],need[safe[n]][2],allocation[safe[n]][0],allocation[safe[n]][1],allocation[safe[n]][2],works[safe[n]][0]+allocation[safe[n]][0],works[safe[n]][1]+allocation[safe[n]][1],works[safe[n]][2]+allocation[safe[n]][2],finish[n]); }

int check() //安全性算法 {

printf(\开始执行安全性算法……\\n\

for (m=0;m<3;m++) //数组work和finish初始化

work[m]=available[m]; line();

for (n=0;n<5;n++) { } k=0;

for (m=0;m<5;m++)

for (n=0;n<5;n++)

if(strcmp(finish[n],\

&&

need[n][0]<=work[0]

&&

finish[n]=\safe[n]=0;

need[n][1]<=work[1] && need[n][2]<=work[2]) //查找可以分配资源但尚未分配到资源的进程

{

safe[k]=n; //以数组safe[k]记下各个进程得到分配的资源的顺序 works[safe[k]][0]=work[0]; works[safe[k]][1]=work[1]; works[safe[k]][2]=work[2];

源

work[0]+=allocation[n][0]; //进程执行后释放出分配给它的资

}

work[1]+=allocation[n][1]; work[2]+=allocation[n][2];

finish[n]=\变为1以示该进程完成本次分 k++;

for (m=0;m<5;m++) //判断是否所有进程分配资源完成 {

if (strcmp(finish[m],\{ } else

if (m==4) //此处m=4表示所有数组finish的所有元素都为ture {

printf(\找到安全序列P%d->P%d->P%d->P%d->P%d，系统是安printf(\找不到安全序列，系统处于不安全状态。\\n\return 0; //找不到安全序列，结束check函数，返回0

全的\\n\ }

void main() //主程序开始 {

start();

for (;j==0;) //确认输入数据的正确性，若输入错误，重新输入 { } return 1;

}

j=1;

outputsafe(); //输出安全序列的资源分配表

}

input();

printf(\以下为进程资源情况，请确认其是否正确：\\n\output();

printf(\数据是否无误：\\n正确：输入1\\n错误：输入0\\n请输入：\scanf(\

printf(\数据确认无误，算法继续。\\n\

if (check()==0) //若check函数返回值为0，表示输入的初始数据找不到

安全序列，无法进行下一步，程序结束

{ }

for(;j==1;) //当有多个进程请求资源时，循环开始 {

printf(\请输入请求资源的进程i(0、1、2、3、4)：\ //输入发出请求向end(); exit(0);

量的进程及请求向量

scanf(\

printf(\请输入进程P%d的请求向量Request%d：\for(n=0;n<3;n++) for

scanf(\

(;request[i][0]>need[i][0]

||

request[i][1]>need[i][1]

||

request[i][2]>need[i][2];) //若请求向量大于需求资源，则认为是输入错误，要求重新输入

{

printf(\数据输入有误，请重试！\\n请输入进程P%d的请求向量

Request%d：\

}

for(n=0;n<3;n++)

scanf(\

if(request[i][0]<=available[0] && request[i][1]<=available[1] &&

request[i][2]<=available[2]) //判断系统是否有足够资源提供分配

{ } else

printf(\系统没有足够的资源，进程P%d需要等待。\\n\printf(\系统正在为进程P%d分配资源……\\n\change(); //分配资源 j=0;

if (j==0) //j=0表示系统有足够资源分配的情况 {

printf(\当前系统资源情况如下：\\n\ //输出分配资源后的系统资源

分配情况

}

printf(\是否还有进程请求资源？\\n是：输入1\\n否：输入0\\n请输入：\scanf(\ //若还有进程请求资源，j=1，之前的for循环条件

output();

if(check()==0) //若找不到安全系列，则之前的资源分配无效 { }

printf(\本次资源分配作废，恢复原来的资源分配状态。\\n\for (m=0;m<3;m++) //恢复分配资源前的系统资源状态 { }

available[m]+=request[i][m]; allocation[i][m]-=request[i][m]; need[i][m]+=request[i][m];

output(); //输出系统资源状态

满足

}

end();

} 结果分析

三、 实验总结及心得体会

多个进程同时运行时，系统根据各类系统资源的最大需求和各类系统的剩余资源为进程安排安全序列，使得系统能快速且安全地进

程，不至发生死锁。银行家算法是避免死锁的主要方法，其思路在很多方面都非常值得我们来学习借鉴。

本文来源：https://www.bwwdw.com/article/nji3.html