银行家算法解析及其C语言程序实现.docx

银行家算法解析及其C语言程序实现.docx

《银行家算法解析及其C语言程序实现.docx》由会员分享，可在线阅读，更多相关《银行家算法解析及其C语言程序实现.docx（11页珍藏版）》请在冰豆网上搜索。

银行家算法解析及其C语言程序实现

银行家算法解析及其Ｃ语言程序实现

　　摘要:

银行家算法是《计算机操作系统》课程中重点和难点之一,就笔者所在学校学生而言,大部分学生可以应用该算法理论做对课本习题,但对计算机利用该算法避免死锁的思想往往一知半解。

本文旨在对该算法进行更直观形象的论述,同时用C程序编写了一个该算法的程序,读者可以不加修改即可在VC6.0上运行,以进一步加深对银行家算法的理解。

　　关键词:

银行家算法安全状态安全序列

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

其基本原理是将系统分为安全状态和不安全状态,并始终保持系统在安全状态下运行,从而避免发生死锁。

　　安全状态是指系统中存在一个以上安全序列的系统状态,在安全状态下可以保证系统不发生死锁。

反之则为不安全状态,在不安全状态下若无外力因素系统将不可避免的发生死锁。

　　那么什么是安全序列呢?

　　安全序列是指系统中所有进程构成的全排列,如果按照此排列所规定的顺序执行各进程,则可以保证每个进程都能获得足够的资源,从而避免系统死锁。

例如:

系统某时刻有n个进程,那么它们所组成的全排列总数是n!

个,如果系统按p1,p2,...pn顺序执行各个进程,每个进程都能得到足够的资源,那么该排列就是一个安全序列。

需要注意的是:

不是所有的全排列都是安全系列,安全序列的个数和长度是动态变化的,因为系统中的进程数和资源的分配情况在随时改变。

　　我们可以这样通俗的来描述银行家算法:

把操作系统看作银行家,操作系统管理的各种计算机资源相当于银行的资金。

把进程看作银行的客户,进程向操作系统请求分配资源相当于客户向银行贷款。

银行家在批准客户的每一笔贷款时都要事先进行评估,以保证银行最终可以为所有的客户提供完整的贷款数量,避免出现所有客户获得的贷款都不完整。

这样一方面客户不能偿还银行贷款（贷款总额没完成）,另一方面银行又没有资金继续为客户提供剩余贷款（此即计算机的死锁状态）。

那么银行在发放贷款时当然事先要有一套可以推算该笔贷款是否能够引起上述情况的方法,即银行家算法。

若用该方法检测可知上述情况不会发生,则予批准,否则取消该笔贷款。

在计算机中操作系统就是按照类似的方法为进程分配资源的。

根据课程内容笔者设计了一个简单的银行家算法教学程序,下面我们来看看该算法的具体实现:

　　符号说明:

　　n:

表示系统中进程的总数

　　m:

表示资源类总数

　　Available用于记录可用剩余资源数,是长度为n的向量。

　　Max用于记录各进程对各种资源的最大需求数量,是n×m的矩阵。

　　Allocation用于记录各进程已分配到的各类资源数量,是n×m的矩阵。

　　Need用于记录各进程对各类资源还需求的数量,是n×m的矩阵。

　　介于系统中的进程数及资源数都是动态变化的,所以以上各数据结构均用链表实现。

由于篇幅所限,本文对两处结构类似代码作了删减,读者只需稍加修改即可运行,代码如下:

　　#include＜iostream.h＞

　　#include＜stdio.h＞

　　//各数据结构定义

　　structallocation

　　{

　　intvalue;

　　structallocation*next;

　　};

　　依此格式,分别定义max,available,need,finish,safepath结构体。

　　intmain（）

　　{

　　introw,coloum,flag=0,i,j;

　　structallocation*allochead,*alloc1,*alloc2,*alloctemp,*alloctemp1;

　　structmax*maxhead,*max1,*max2,*maxtemp;

　　structavailable*avahead,*ava1,*ava2,*avatemp,*workhead,*work1,*work2,*worktemp,*totalhead,*total1,*total2,*totaltemp;

　　structneed*needhead,*need1,*need2,*needtemp;

　　structfinish*finishhead,*finish1,*finish2,*finishtemp;

　　structsafepath*safehead,*safe1,*safe2,*safetemp;

　　cout＜＜"请输入系统中的进程数:

";

　　cin＞＞row;

　　cout＜＜endl＜＜"请输入系统中的资源种数";

　　cin＞＞coloum;

　　cout＜＜"初始化系统中各种资源总数:

"＜＜endl;

　　for（j=0;j＜coloum;j++）

　　{

　　if（flag==0）

　　{

　　totalhead=total1=total2=new（structavailable）;

　　total1-＞next=total2-＞next=NULL;

　　cin＞＞total1-＞value;

　　flag++;

　　}

　　else

　　{

　　total2=new（structavailable）;

　　cin＞＞total2-＞value;

　　if（flag==1）

　　{

　　totalhead-＞next=total2;

　　flag++;

　　}

　　total1-＞next=total2;

　　total1=total2;

　　}

　　}

　　total2-＞next=NULL;

　　flag=0;

　　cout＜＜"初始化已分配资源矩阵"＜＜endl;

　　for（i=0;i＜row;i++）

　　{

　　for（j=0;j＜coloum;j++）

　　{

　　printf（"请输入已分配给进程p%d的R%d类资源:

",i,j）;

　　if（flag==0）

　　{

　　allochead=alloc1=alloc2=new（structallocation）;

　　alloc1-＞next=alloc2-＞next=NULL;

　　cin＞＞allochead-＞value;

　　flag++;

　　}

　　else

　　{

　　alloc2=new（structallocation）;

　　cin＞＞alloc2-＞value;

　　if（flag==1）

　　{

　　allochead-＞next=alloc2;

　　flag++;

　　}

　　alloc1-＞next=alloc2;

　　alloc1=alloc2;

　　}

　　}

　　}

　　alloc2-＞next=NULL;

　　flag=0;

　　用同上的方法初始化最大需求矩阵,读者可自行在此添加。

　　//通过最大需求矩阵和已分配矩阵计算需求矩阵

　　alloctemp=allochead;

　　maxtemp=maxhead;

　　for（i=0;i＜row;i++）

　　{

　　for（j=0;j＜coloum;j++）

　　{

　　if（flag==0）

　　{

　　needhead=need1=need2=new（structneed）;

　　need1-＞next=need2-＞next=NULL;

　　need1-＞value=maxtemp-＞value-alloctemp-＞value;

　　flag++;

　　}

　　else

　　{

　　need2=new（structneed）;

　　need2-＞value=maxtemp-＞value-alloctemp-＞value;

　　if（flag==1）

　　{

　　needhead-＞next=need1;

　　flag++;

　　}

　　need1-＞next=need2;

　　need1=need2;

　　}

　　maxtemp=maxtemp-＞next;

　　alloctemp=alloctemp-＞next;

　　}

　　}

　　need2-＞next=NULL;

　　flag=0;

　　用上面初始化系统中各种资源总数的方法初始化finish向量,读者可自行在此添加。

　　//计算available向量

　　//先创建available向量并赋初始值为各系统资源总数

　　totaltemp=totalhead;

　　for（j=0;j＜coloum;j++）

　　{

　　if（flag==0）

　　{

　　avahead=ava1=ava2=new（structavailable）;

　　ava1-＞next=ava2-＞next=NULL;

　　ava1-＞value=totaltemp-＞value;

　　totaltemp=totaltemp-＞next;

　　flag++;

　　}

　　else

　　{

　　ava2=new（structavailable）;

　　ava2-＞value=totaltemp-＞value;

　　totaltemp=totaltemp-＞next;

　　if（flag==1）

　　{

　　avahead-＞next=ava2;

　　flag++;

　　}

　　ava1-＞next=ava2;

　　ava1=ava2;

　　}

　　}

　　ava1-＞next=NULL;

　　flag=0;

　　//通过已分配矩阵和各系统资源总数计算available向量的实际值;

　　alloctemp=allochead;

　　avatemp=avahead;

　　for（i=0;i＜row;i++）

　　{for（j=0;j＜coloum;j++）

　　{

　　avatemp-＞value-=alloctemp-＞value;

　　avatemp=avatemp-＞next;

　　alloctemp=alloctemp-＞next;

　　}

　　avatemp=avahead;

　　}

　　//开始安全性算法

　　//初始化work向量

　　avatemp=avahead;

　　for（j=0;j＜coloum;j++）

　　{

　　if（flag==0）

　　{

　　workhead=work1=work2=new（structavailable）;

　　work1-＞next=work2-＞next=NULL;

　　work1-＞value=avatemp-＞value;

　　avatemp=avatemp-＞next;

　　flag++;

　　}

　　else

　　{

　　work2=new（structavailable）;

　　work2-＞value=avatemp-＞value;

　　avatemp=avatemp-＞next;

　　if（flag==1）

　　{

　　workhead-＞next=work2;

　　flag++;

　　}

　　work1-＞next=work2;

　　work1=work2;

　　}

　　}

　　work1-＞next=NULL;

　　flag=0;

　　//开始安全性算法

　　inttest=0;

　　intk;

　　for（k=0;k＜row;k++）

　　{

　　alloctemp=allochead;

　　needtemp=needhead;

　　finishtemp=finishhead;

　　worktemp=workhead;

　　for（i=0;i＜row;i++,finishtemp=finishtemp-＞next）

　　{

　　worktemp=workhead;

　　alloctemp1=alloctemp;

　　if（finishtemp-＞value==0）

　　{

　　for（j=0,test=0,worktemp=workhead;j＜coloum;j++）

　　{

　　if（needtemp-＞value＜=worktemp-＞value）

　　{test++;}

　　needtemp=needtemp-＞next;

　　alloctemp=alloctemp-＞next;

　　worktemp=worktemp-＞next;

　　}

　　worktemp=workhead;

　　//如果该进程能够获得足够资源则回收其已分配的资源

　　if（test==coloum）

　　{

　　for（j=0;j＜coloum;j++）

　　{

　　worktemp-＞value+=alloctemp1-＞value;

　　alloctemp1=alloctemp1-＞next;

　　worktemp=worktemp-＞next;

　　}

　　//将该进程插入安全序列链表

　　if（flag==0）

　　{

　　safehead=safe1=safe2=new（structsafepath）;

　　safe1-＞next=safe2-＞next=NULL;

　　safe1-＞value=i;

　　flag++;

　　}

　　else

　　{

　　safe2=new（structsafepath）;

　　safe2-＞value=i;

　　if（flag==1）

　　{

　　safehead-＞next=safe2;

　　flag++;

　　}

　　safe1-＞next=safe2;

　　safe1=safe2;

　　}

　　//将该进程的完成标志置为真;

　　finishtemp-＞value=1;

　　}

　　}

　　else

　　for（j=0;j＜coloum;j++）

　　{

　　needtemp=needtemp-＞next;

　　alloctemp=alloctemp-＞next;

　　}

　　}

　　}

　　//输出系统安全情况

　　safetemp=safehead;

　　finishtemp=finishhead;

　　for（i=0;i＜row;i++）

　　{if（finishtemp-＞value!

=1）break;}

　　if（i==row）

　　{cout＜＜"该系统为安全状态,安全序列为:

";

　　for（i=0;i＜row;i++）

　　{cout＜＜"p"＜＜safetemp-＞value＜＜",";safetemp=safetemp-＞next;}

　　}

　　else

　　cout＜＜"该系统为不安全状态!

";

　　cout＜＜endl;

　　return（0）;

　　}

　　参考文献:

　　[1]汤子羸,《计算机操作系统》,西安电子科技大学出版社。