银行家算法课程设计报告 (1)操作系统

目录

1. 设计目的 (1)

2. 问题描述 (1)

3. 需求分析 (1)

3.1 数据需求 (1)

3.2 基本功能需求 (1)

3.3 非功能性需求 (1)

4. 概要设计 (1)

4.1 数据结构 (1)

4.2 系统功能模块介绍 (2)

4.2.1 数据定义 (2)

4.2.2 输出矩阵 (2)

4.2.3 试分配资源 (2)

4.2.4 安全性检测 (2)

4.3 系统功能模块图 (2)

5. 详细设计 (2)

5.1 系统函数详细介绍 (2)

5.2 银行家算法 (3)

5.3 安全性算法 (4)

5.4 程序流程图 (4)

6. 调试分析 (6)

7. 使用说明 (8)

8. 设计总结 (8)

9. 参考文献 (9)

10.程序源代码 (9)

1.设计目的

通过银行家算法设计与实现，可以加深学生对死锁的理解，掌握死锁的预防、避免、检测和解除的基本原理，重点掌握死锁的避免方法—银行家算法。使学生初步具有研究、设计、编制和调试操作系统模块的能力。

2.问题描述

设计一个进程动态请求资源的模拟系统，实现随机产生进程请求资源的数量；资源安全性检查算法；资源的分配算法；以及输出显示每次请求的结果和系统资源的状态。

3.需求分析

3.1数据需求

字符范围：0,1,2……n

3.2基本功能需求

为进程随机产生请求资源的数量，系统通过资源安全性检查，检查是否满足安全要求。若安全，则才分配资源；不安全时，系统恢复申请前的状态；只有当进程满足全部的资源需求时，该进程执行结束，释放所占的资源。

3.3非功能性需求

用户界面需求：简洁、易用、易懂、友好的用户界面。

硬件需求：Windows 7系统，VC++6.0开发工具。

4.概要设计

4.1数据结构

主要用到的数据结构：

(1) 最大需求矩阵Max[][]

(2) 已分配矩阵Allocation[][]

(3) 仍需求矩阵Need[][]=Max[][]-Allocation[][]

(4) 可利用资源向量Available[]

(5) 申请各类资源向量Request[]

(6) 工作向量work[] , Finish[]

4.2系统功能模块介绍

4.2.1数据定义

int Max[MaxResource]

int Allocation[MaxResource]

int Need[MaxResource]

4.2.2试分配资源

据用户输入的数据进行试分配

4.2.3输出矩阵

据输入数据输出对应矩阵，并计算出需求矩阵

4.2.4安全性检测

进程间是安全的时候则可以输出相应的安全序列。如果错误，则可以回到数据的初始化状态

4.3系统功能模块图

图4.3-1 功能模块图

5.详细设计

5.1系统函数详细介绍

int Max[MaxResource] // 表示某个进程对某类资源的最大需求

int Allocation[MaxResource] // 表示某个进程已分配到某类资源的个数 int Need[MaxResource] // 表示某个进程尚需要某类资源的个数

int mark[MaxResource] //在使用FreeRecourse是以确定是否释放资

源

void Initialize(pcb *&head,int m,int n, int Available[MaxResource]) //初始化进程资源值

void AddPcb(pcb *&head,pcb node) //增加进程链表块

void ShowPcb(pcb *head,int *avail,int m) //显示进程初始化的资源值pcb *Seek(pcb *head,int pid) //查找进程在链表中的位置void FreeResource(pcb *&head,int Available[MaxResource],int m)//若进程所需资源已全部分配，则释放该进程占据的全部系统资源

pcb *Application(pcb *head,int *request,int *avail,int m) //再次给进程分配资源

pcb *Reasonable(pcb *head,int *finish,int *work,int m,int n) //找到当前安全可执行的进程返回

void Alter(pcb *p,int* work,int* finish,int record[][MaxResource],int m) //修改相关进程的资源值

int SafetyCheck(pcb *head,int *avail,int *safety,int Record[][MaxResource],int m,int n) //进程安全性算法

void ReturnSource(pcb *p,int *request,int *avail,int m) //若试分配失败，则恢复试分配前的资源状态

void main() //主函数

5.2银行家算法

（1）如果Requesti＜or =Need,则转向步骤(2)；否则，认为出错，因为它所需要的资源数已超过它所宣布的最大值。

（2）如果Request＜or=Available,则转向步骤（3）；否则，表示系统中尚无足够的资源，进程必须等待。

（3）系统试探把要求的资源分配给进程Pi,并修改下面数据结构中的数

值：

Available=Available-Request[i];

Allocation=Allocation+Request;

Need=Need-Request;

(4)系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。

5.3安全性算法

（1）设置两个向量

①工作向量Work。它表示系统可提供进程继续运行所需要的各类资源数目，执行安全算法开始时，Work=Allocation;

②布尔向量Finish。它表示系统是否有足够的资源分配给进程，使之运行完成，开始时先做Finish[i]=false，当有足够资源分配给进程时，令Finish[i]=true。（2）从进程集合中找到一个能满足下述条件的进程：①Finish[i]=false ②Need

（3）当进程P获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行： Work=Work+Allocation; Finish[i]=true; 转向步骤（2）。（4）如果所有进程的Finish[i]=true,则表示系统处于安全状态；否则，系统处于不安全状态。

5.4程序流程图

主程序流程图：

图5.4-1 主程序模块图

图5.4-2 银行家算法安全性检查算法流程图：

图5.4-3 安全检查算法

图5.4-4 释放资源算法6.调式分析

图6-1 初始化资源信息

图6-2 随机分配资源并进行安全检查

图6-2系统给进程0、1随机分配资源，显示所需的资源数。安全信息检查，输出安全序列号

图6-3 进程再申请资源

图6-3为给进程0再次分配资源，当满足所需资源时，进程执行完，释放系统所占的资源。

图6-4 分配资源超过可利用资源

图6-4分配资源超过可利用资源，系统处于不安全状态，本次申请作废，恢复原来的资源分配状态。

7.使用说明

按屏幕提示输入进程数。按回车键，输入资源数。按回车键输入系统中可利用的资源数值。回车后据提示输入第0个进程最大需求资源数。屏幕会显示给进程0随机分配的资源数和其所需资源数。据屏幕提示输入下一进程最大所需资源数。回车显示给下一进程随机分配的资源数和其所需资源数。循环操作直至分配完成。显示进程的资源分配信息，并检测其安全性。若显示安全，则可继续分配资源。不安全则本次申请分配作废，恢复原来的分配状态。

8.设计总结

通过这次实验，让我更加全面的复习C语言，也让我加深了操作系统的知识，知道了系统给进程分配资源时解决死锁的方法，对安全算法和银行家算法有了一定的了解。以前的自己C语言的编程还是有些基础，也做了大量的编程题，

所以，编程不是主要的问题。主要的问题就是对于操作系统系统分配资源的不熟悉，以及试验中所遇到的算法的了解不够，致使在编程中出现了一些错误，之后，通过借阅图书馆的书籍，查阅相关的资料，弄懂了算法的含义，解决了相关的问题，让我收获不少。

9.参考文献

[1]汤小丹等编著.计算机操作系统（第三版）.西安：西安电子科技大学出版社，2007.5

[2]史美林编.计算机操作系统教程.北京：清华大学出版社，1999.11

[3]徐甲同编著.操作系统教程.西安：西安电子科技大学出版社，1996.8

[4]Clifford，A.Shaffer编著.数决结构与算法分析(C++版).北京：电子工业出版社，2005.7

[5]蒋立翔编著.C++程序设计技能百练.北京：中国铁道出版社，2004.1

10.程序源代码

#include

#include

#include

#define MaxResource 10 // 最大系统资源类

#define NULL 0

struct pcb //定义进程控制块PCB

{

int pid; //进程标号

int Max[MaxResource]; // 表示某个进程对某类资源的最大需求

int Allocation[MaxResource]; // 表示某个进程已分配到某类资源的个数 int Need[MaxResource]; // 表示某个进程尚需要某类资源的个数

int mark[MaxResource]; //在使用FreeRecourse是以确定是否释放资源

pcb *next;

};

void Initialize(pcb *&head,int m,int n, int Available[MaxResource]) //初始化进程资源值

{

int i,j=0;

void AddPcb(pcb *&head,pcb node);

pcb node;

printf("\t**请输入%d进程的%d个最大资源数**\t\n",n,m);

do{

node.pid=j;

printf("请输入第 %d个进程最大需求资源数:\n",node.pid);

for(i=0;i

scanf("%d",&node.Max[i]);

printf("系统给进程%d随机分配资源数为:\n ",node.pid);

for(i=0;i

{

node.Allocation[i]=rand()%node.Max[i];

printf("%10d",node.Allocation[i]);

Available[i]=Available[i]-node.Allocation[i];

}

printf("\n");

printf("进程%d还所需的资源数为:\n",node.pid);

for(i=0;i

{

node.Need[i]=node.Max[i]-node.Allocation[i];

printf("%10d",node.Need[i]);

}

for(i=0;i

node.mark[i]=0;

printf("\n");

AddPcb(head,node);

j++;

}while(j

}

void AddPcb(pcb *&head,pcb node) //增加进程链表块

{

pcb *p=(pcb*)malloc(sizeof(pcb));

pcb *last=NULL;

memcpy(p,&node,sizeof(pcb));

p->next=NULL;

if(head==NULL)head=p;

else

{

last=head;

while(last->next!=NULL)

last=last->next;

last->next=p;

}

}

void ShowPcb(pcb *head,int *avail,int m) //显示进程初始化的资源值{

pcb *p=NULL;

int j;

p=head;

if(p==NULL)

{

printf("当前没有进程，请重新输入进程!\n");

exit(0);

}

else

{

printf("进程号最大资源值已分配资源还需资源可利用的资源状态\n\n");

while(p!=NULL)

{

printf("p[%d]",p->pid);

for(j=0;j

{

printf("\t %4d %4d %4d %4d",p->Max[j],p->Alloc ation[j],p->Need[j],avail[j]);

if(p->mark[j])printf(" 已执行\n");

else printf(" 等待\n");

}

p=p->next;

}

}

}

pcb *Seek(pcb *head,int pid) //查找进程在链表中的位置

{

pcb *p=NULL;

p=head;

if(p==NULL)

{

printf("没有进程，进程链表空！\n");

return p;

}

else

{

while(p!=NULL)

{

if(p->pid==pid)break;

else

p=p->next;

}

if(NULL==p)

{

printf("没有这个进程！\n");

return p;

}

else

return p;

}

}

void FreeResource(pcb *&head,int Available[MaxResource],int m)//若进程所需资源已全部分配，则释放该进程占据的全部系统资源

{

pcb *p=NULL;

int i;

p=head;

if(!p)printf("没有进程，请先初始化进程！");

else

{

for(i=0;i

{

if((p->Need[i]==NULL)&&(p->mark[i]==NULL))

{

printf("进程%d的第%d个已经执行完，释放所占系统资源！\n",p->pid,i);

Available[i]+=p->Allocation[i];

p->mark[i]=1;

}

}

}

}

pcb *Application(pcb *head,int *request,int *avail,int m) //再次给进程分配资源

{

int pid,i;

pcb *p=NULL;

printf("请输入进程pid号: \n");

printf("p");

scanf("%d",&pid);

p=Seek(head,pid);

if(p==NULL)

{

printf("没有这个进程！\n");

return p;

}

printf("请输入给该进程再次分配的资源数: \n");

for(i=0;i

scanf("%d",&request[i]);

for(i=0;i

if(request[i]>p->Need[i])

{

printf("分配进程的资源数超过最大资源数！\n");

return NULL;

}

for(i=0;i

if(request[i]>avail[i])

{

printf("分配进程的资源数超过可利用的资源数！\n");

return NULL;

}

for(i=0;i

{

avail[i]=avail[i] - request[i];

p->Allocation[i]=p->Allocation[i] + request[i];

p->Need[i]=p->Need[i] - request[i];

}

FreeResource(p,avail,m);

return p;

}

pcb *Reasonable(pcb *head,int *finish,int *work,int m,int n) //找到当前安全可执行的进程返回

{

int i=0,j=0,count=0;

pcb *p=NULL;

while(1)

{

if(finish[i]!=-1)

{

p=Seek(head,finish[i]);

if(p!=NULL)

{

for(j=0;j

{

if(p->Need[j]>work[j])break;

else continue;

}

if(j==m)return p;//p进程安全

else i++;

}

}

else i++;

if(i==n)return NULL;

}

}

void Alter(pcb *p,int* work,int* finish,int record[][MaxResource],int m) //修改相关进程的资源值

{

int i;

for(i=0;i

record[p->pid][i]=work[i];

work[i]=work[i]+p->Allocation[i];

}

finish[p->pid]=-1;

}

int SafetyCheck(pcb *head,int *avail,int *safety,int Record[][MaxResource],int m,int n) //进程安全性算法

{

int *work=NULL;

int *finish=NULL;

pcb *p=NULL;

pcb *pro=NULL;

int i,count=0;

work=(int*)malloc(m*sizeof(int));

finish=(int*)malloc(n*sizeof(int));

p=head;

for(i=0;i

work[i]=avail[i];

i=0;

while(p!=NULL)

{

finish[i]=p->pid;

p=p->next;

i++;

}

i=0;

while(count

pro=Reasonable(head,finish,work,m,n);

if(pro!=NULL)

{

Alter(pro,work,finish,Record,m);

count++;

safety[i]=pro->pid;

i++;

}

else

{

printf("当前的系统处于不安全状态！\n");

break;

}

}

if(count==n)

{

printf("当前系统处于安全状态,存在一个安全序列 :\n");

for(i=0;i

printf("p[%d]->",safety[i]);

printf("\n");

}

free(finish);

free(work);

finish=NULL;

work=NULL;

if(count==n)return 1;

else return 0;

}

void ReturnSource(pcb *p,int *request,int *avail,int m) //若试分配失败，则恢复试分配前的资源状态

{

int i;

for(i=0;i

{

p->Allocation[i]-=request[i];

p->Need[i]+=request[i];

avail[i]+=request[i];

}

}

void main()

{

int n,m;

char ch;

int i,flag=0;

int Available[MaxResource]={0};

int Request[MaxResource]={0};

int Record[MaxResource][MaxResource]={0};

int Safety[MaxResource]={0}; //记录安全序列

pcb *head,*process;

head=NULL;process=NULL;

printf("请输入进程数：\n");

scanf("%d",&n);

printf("请输入资源数：\n");

scanf("%d",&m);