实验四银行家算法的实现.docx

实验四银行家算法的实现.docx

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

实验四银行家算法的实现

银行家算法的实现

一、初始化

由用户输入数据，分别对可利用资源向量矩阵AVAILABLE、最大需求矩阵MAX、分配矩阵ALLOCATION、需求矩阵NEED赋值。

二、银行家算法

在避免死锁的方法中，所施加的限制条件较弱，有可能获得令人满意的系统性能。

在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统始终都处于安全状态，便可以避免发生死锁。

银行家算法的基本思想是分配资源之前,判断系统是否是安全的;若是,才分配。

它是最具有代表性的避免死锁的算法。

设进程cusneed提出请求REQUEST[i]，则银行家算法按如下规则进行判断。

（1）如果REQUEST[cusneed][i]<=NEED[cusneed][i]，则转

（2）；否则，出错。

（2）如果REQUEST[cusneed][i]<=AVAILABLE[cusneed][i]，则转（3）；否则，出错。

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

AVAILABLE[i]-=REQUEST[cusneed][i];

ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];

NEED[cusneed][i]-=REQUEST[cusneed][i];

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

三、安全性检查算法

（1）设置两个工作向量Work=AVAILABLE;FINISH

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

FINISH==false;

NEED<=Work;

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

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

Work+=ALLOCATION;

Finish=true;

GOTO2

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

 各算法流程图

初始化算法流程图：

银行家算法流程图：

安全性算法流程图：

源程序清单

#include

usingnamespacestd;

#defineMAXPROCESS50                       /*最大进程数*/

#defineMAXRESOURCE100                       /*最大资源数*/

intAVAILABLE[MAXRESOURCE];                   /*可用资源数组*/

intMAX[MAXPROCESS][MAXRESOURCE];           /*最大需求矩阵*/

intALLOCATION[MAXPROCESS][MAXRESOURCE];   /*分配矩阵*/

intNEED[MAXPROCESS][MAXRESOURCE];           /*需求矩阵*/

intREQUEST[MAXPROCESS][MAXRESOURCE];       /*进程需要资源数*/

boolFINISH[MAXPROCESS];                       /*系统是否有足够的资源分配*/

intp[MAXPROCESS];                            /*记录序列*/

intm,n;                                   /*m个进程,n个资源*/

voidInit（）;

boolSafe（）;

voidBank（）;

intmain（）

{

   Init（）;

   Safe（）;

   Bank（）;

}

voidInit（）               /*初始化算法*/

{

   inti,j;

   cout<<"请输入进程的数目:

";

   cin>>m;

   cout<<"请输入资源的种类:

";

   cin>>n;

   cout<<"请输入每个进程最多所需的各资源数,按照"<

   for（i=0;i

   for（j=0;j

   cin>>MAX[i][j];

   cout<<"请输入每个进程已分配的各资源数,也按照"<

   for（i=0;i

   {

       for（j=0;j

       {

           cin>>ALLOCATION[i][j];

           NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];

           if（NEED[i][j]<0）

           {

               cout<<"您输入的第"<

"<

               j--;

               continue;

           }

       }

   }

   cout<<"请输入各个资源现有的数目:

"<

   for（i=0;i

   {

       cin>>AVAILABLE[i];

   }

}

voidBank（）               /*银行家算法*/

{

   inti,cusneed;

   charagain;

   while

（1）

   {

       cout<<"请输入要申请资源的进程号（注:

第1个进程号为0,依次类推）"<

       cin>>cusneed;

       cout<<"请输入进程所请求的各资源的数量"<

       for（i=0;i

       {

           cin>>REQUEST[cusneed][i];

       }

       for（i=0;i

       {

           if（REQUEST[cusneed][i]>NEED[cusneed][i]）

           {

               cout<<"您输入的请求数超过进程的需求量!

请重新输入!

"<

               continue;

           }

           if（REQUEST[cusneed][i]>AVAILABLE[i]）

           {

               cout<<"您输入的请求数超过系统有的资源数!

请重新输入!

"<

               continue;

           }

       }

       for（i=0;i

       {

           AVAILABLE[i]-=REQUEST[cusneed][i];

           ALLOCATION[cusneed][i]+=REQUEST[cusneed][i];

           NEED[cusneed][i]-=REQUEST[cusneed][i];

       }

       if（Safe（））

       {

           cout<<"同意分配请求!

"<

       }

       else

       {

           cout<<"您的请求被拒绝!

"<

           for（i=0;i

           {

               AVAILABLE[i]+=REQUEST[cusneed][i];

               ALLOCATION[cusneed][i]-=REQUEST[cusneed][i];

               NEED[cusneed][i]+=REQUEST[cusneed][i];

           }

       }

       for（i=0;i

       {

           FINISH[i]=false;

       }

       cout<<"您还想再次请求分配吗?

是请按y/Y,否请按其它键"<

       cin>>again;

       if（again=='y'||again=='Y'）

       {

           continue;

       }

       break;

       }

}

boolSafe（）                                   /*安全性算法*/

{

   inti,j,k,l=0;

   intWork[MAXRESOURCE];                   /*工作数组*/

   for（i=0;i

   Work[i]=AVAILABLE[i];

   for（i=0;i

   {

       FINISH[i]=false;

   }

   for（i=0;i

   {   

       if（FINISH[i]==true）

       {

           continue;

       }

       else

       {

           for（j=0;j

           {

               if（NEED[i][j]>Work[j]）

               {

                   break;

               }

           }

           if（j==n）

           {

               FINISH[i]=true;

               for（k=0;k

               {

                   Work[k]+=ALLOCATION[i][k];

               }

               p[l++]=i;

               i=-1;

           }

           else

           {

               continue;

           }

       }

       if（l==m）

       {

           cout<<"系统是安全的"<

           cout<<"安全序列:

"<

           for（i=0;i

           {

               cout<

               if（i!

=l-1）

               {

                   cout<<"-->";

               }

           }

           cout<<""<

           returntrue;

       }

   }

   cout<<"系统是不安全的"<

   returnfalse;

}