【操作系统 - 3】预防进程死锁的银行家算法

操作系统系列

  学习至此，发现很多学了但很久没用的知识，久而久之，慢慢遗忘。等哪天还需要的话，却发现已经忘得差不多了，即使整理了文档（word等），还是得从头再学一遍。读研第一学期，发现很多东西都可以从博客上学习到，也有不少博主呕心沥血整理了挺多有用的博文。于是，本人借此契机，也慢慢开始整理一些博文，不断改进完善中。整理博文（IT）有如下目的：

首要目的：记录“求学生涯”的所学所悟，不断修改，不断更新！（有读者的互动）
其次目的：在这“开源”的时代，整理并分享所学所悟是一种互利的行为！
博文系列：操作系统课程所学相关算法

1.先来先服务FCFS和短作业优先SJF进程调度算法

2.时间片轮转RR进程调度算法

3.预防进程死锁的银行家算法

4.动态分区分配算法

5.虚拟内存页面置换算法

6.磁盘调度算法
6个实验相关代码的下载地址：http://download.csdn.net/detail/houchaoqun_xmu/9865648

-------------------------------

预防进程死锁的银行家算法

一、概念介绍和案例解析

银行家算法中的数据结构

可利用资源向量Available。这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。如果Available[j]=K，则表示系统中现有Rj类资源K个。

最大需求矩阵Max。这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i,j]=K，则表示进程i需要Rj类资源的最大数目为K。

分配矩阵Allocation。这也是一个n×m的矩阵，它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation[i,j]=K，则表示进程i当前已分得Rj类资源的数目为K。

需求矩阵Need。这也是一个n×m的矩阵，用以表示每一个进程尚需的各类资源数。如果Need[i,j]=K，则表示进程i还需要R j类资源K个，方能完成其任务。

上述三个矩阵间存在下述关系：Need[i, j]=Max[i, j]-Allocation[i, j]

银行家算法
  设Request i是进程Pi的请求向量，如果Request i[j]=K，表示进程P i需要K个R j类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查：

如果Request i[j]≤Need[i,j]，便转向步骤(2)；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。

如果Requesti[j]≤Available[j]，便转向步骤(3)；否则，表示尚无足够资源，Pi须等待。

系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值（红色字体）：

系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。

Available[j]:= Available[j]-Requesti[j]；

Allocation[i,j]:= Allocation[i,j]+Requesti[j]；
Need[i,j]:= Need[i,j]-Request i[j]；

安全性算法
  系统所执行的安全性算法可描述如下：

设置两个向量：第一个是工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，它含有m个元素，在执行安全算法开始时，Work:=Available。第二个是Finish，它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish[i]:=false；当有足够资源分配给进程时，再令Finish[i]:=true。

从进程集合中找到一个能满足下述条件的进程：第一【Finish[i]=false；】第二【Need[i,j]≤Work[j]；若找到，执行步骤(3)，否则，执行步骤(4)】。

当进程Pi获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：【Work[j]:= Work[j]+Allocation[i,j]；】【Finish[i]:=true；】【go to step (2)；】

如果所有进程的Finish[i]=true都满足，则表示系统处于安全状态；否则，系统处于不安全状态。



银行家算法实例
  假定系统中有五个进程{P0，P1，P2，P3，P4}和三类资源{A，B，C}，各种资源的数量分别为10、5、7，在T0时刻的资源分配情况如下图所示：



T0时刻的安全性：利用安全性算法对T0时刻的资源分配情况进行分析，判定在P1发出请求向量Request_1(1，0，2)之前是否安全？即是否存在一个安全序列？



  利用安全性算法对T0时刻的资源分配情况进行分析(见下图所示)可知，在T0时刻存在着一个安全序列{P1，P3，P4，P2，P0}，故系统是安全的：（P1发出请求向量Request1(1，0，2)之前） 



2. P1请求资源：P1发出请求向量Request1(1，0，2)，系统按银行家算法进行检查：
  ① Request1(1，0，2)≤Need1(1，2，2)

  ② Request1(1，0，2)≤Available1(3，3，2)

  ③ 系统先假定可为P1分配资源，并修改Available，Allocation1和Need1向量，由此形成的资源变化情况如本例第一图中的共色圆括号所示。

  ④ 再利用安全性算法检查此时系统是否安全。如下图所示：



3. P4请求资源：P4发出请求向量Request4(3，3，0)，系统按银行家算法进行检查：

  ① Request4(3，3，0)≤Need4(4，3，1)；

  ② Request4(3，3，0)>Available(2，3，0)，让P4等待。

4. P0请求资源：P0发出请求向量Request0(0，2，0)，系统按银行家算法进行检查：

  ① Request0(0，2，0)≤Need0(7，4，3)；

  ② Request0(0，2，0)≤Available(2，3，0)；

  ③ 系统暂时先假定可为P0分配资源，并修改有关数据，如下图所示。 



5. 进行安全性检查：可用资源Available(2，1，0)已不能满足任何进程的需要，故系统进入不安全状态，此时系统不分配资源。如果在银行家算法中，把P0发出的请求向量改为Request0(0，1，0)，系统是否能将资源分配给它，请读者考虑。

二、实验介绍

问题描述：
  设计程序模拟预防进程死锁的银行家算法的工作过程。假设有系统中有n个进程P1, … ,Pn，有m类可分配的资源R1,… ,Rm，在T0时刻，进程Pi分配到的j类资源为Allocationij个，它还需要j类资源Need ij个，系统目前剩余j类资源Workj个，现采用银行家算法进行进程资源分配预防死锁的发生。

程序要求：

判断当前状态是否安全，如果安全，给出安全序列；如果不安全给出理由。

对于下一个时刻T1，某个进程Pk会提出请求Request(R1, … ,Rm)，判断分配给P k进程请求的资源之后是否安全。如果安全，给出安全序列；如果不安全给出理由。
输入：进程个数n，资源种类m，T0时刻各个进程的资源分配情况（可以运行输入，也可以在程序中设置）。

输出：如果安全输出安全的进程序列，不安全提示信息。

三、程序设计

进程调度的实现过程：

变量初始化；

接收用户输入n，m，（输入或者默认的）Allocationij，Need ij；

按照银行家算法判断当前状态安全与否，安全给出安全序列，不安全给出提示；

如果安全，提示用户输入下一时刻进程Pk的资源请求Request(R1, … ,Rm)；

如果不安全或者无新请求则退出。

四、实验结果分析

测试数据1：

当前进程个数 = 5
当前资源个数 = 3

系统可利用资源数情况：3 3 2

Allocation[][] =
0 1 0
2 0 0
3 0 2
2 1 1
0 0 2

Max[][] =
7 4 3
1 2 2
6 0 0
0 1 1
4 3 1

习题and程序验证：建议读者可以先手动算一下该题，验证程序得到的结果。
  在银行家算法中，出现如下资源分配情况：



该状态是否安全，如果不安全说明理由，如果安全给出安全序列。

若进程P3提出请求Request(1,2,1)后，系统是否安全，如果不安全说明理由，如果安全给出分配后的安全序列。

程序执行结果如下：

五、实验源码

// 操作系统_实验三（银行家算法）.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <iomanip>
#include <fstream>
using namespace std;

#define MaxNumber 20

static int n;
static int m;
static int Available[MaxNumber];
static int Max[MaxNumber][MaxNumber];
static int Allocation[MaxNumber][MaxNumber];
static int Need[MaxNumber][MaxNumber];
static int Request[MaxNumber];
static int SafeOrder[MaxNumber];
static bool Finish[MaxNumber];

static bool isDisplayAvaliable = true;
static char sourceName[] = {'A','B','C','D','E','F','G','H','I','J','K'};	  //资源名称

void input();
bool isSystemSafe();
void bankerAlgorithm();
void display();

int main()
{
input();
bankerAlgorithm();
system("pause");
return 0;
}

void input()
{
ifstream inData;
inData.open("data.txt");
//读取数据
inData>>n;
inData>>m;

for (int i=0;i<m;i++)
{
inData>>Available[i];
}

for (int i=0;i<n;i++)
{
for (int j=0;j<m;j++)
{
inData>>Allocation[i][j];
}
}

for (int i=0;i<n;i++)
{
for (int j=0;j<m;j++)
{
inData>>Need[i][j];
}
}

for (int i=0;i<n;i++)
{
for (int j=0;j<m;j++)
{
Max[i][j] = Need[i][j] + Allocation[i][j];
}
}
cout<<"*****************************程序开始*******************************"<<endl;
display();

}

bool isSystemSafe()
{
int work[MaxNumber];
for (int i=0;i<m;i++)   //m是资源个数A,B,C
{
work[i] = Available[i];
}
for (int i=0;i<n;i++)    //n是进程个数
{
Finish[i] = false;
SafeOrder[i] = -1;  //初始化安全序列
}

int FinishNumebr = 0;
int isSafe;
int i =0,j;
while(i<n)
{
isSafe = 0;
for(j = 0;j<m;j++)
{
if (Finish[i]==false && Need[i][j]<=work[j])
{
isSafe++;
}
else
break;
}

if (isSafe == m)  //当且仅当进程对应的所有资源的数量都满足的时候才成立
{
Finish[i] = true;
SafeOrder[FinishNumebr] = i;
FinishNumebr++;
for (j = 0;j<m;j++)
{
work[j] += Allocation[i][j];
}
i=0;  //找到满足条件的进程后，从头开始再进行寻找
}
else
i++;

if (FinishNumebr==n)
{
cout<<"**********************************Safe!******************************"<<endl;
cout<<"对应的安全序列为："<<endl;
cout<<"P"<<SafeOrder[0];
for (int i=1;i<n;i++)
{
cout<<"-->"<<"P"<<SafeOrder[i] ;
}
cout<<endl;
return true;
}
}

cout<<"******************************unSafe!******************************"<<endl;
return false;
}

void bankerAlgorithm()
{
int chooseProcess;
char isContinue;

while(true)
{
//设置两个布尔变量：判别请求向量是等待还是系统已经不再分配新的资源
bool isRequestNeedOK = true;
bool isRequestAvailableOK = true;

cout<<"请输入要申请资源的进程号（注意：第一个进程为0号，第二个进程为1号，以此类推！）"<<endl<<"chooseProcess=";
cin>>chooseProcess;
cout<<"请输入进程所请求的各类资源的数量：(A B C)"<<endl;
for (int i=0;i<m;i++)
{
cin>>Request[i];
}
//输入错误判断
for (int i=0;i<m;i++)
{
if (Request[i]>Need[chooseProcess][i])
{
cout<<"**************************当前运行结果*****************************"<<endl;
cout<<"您输入的请求进程所对应的资源数量超过最大需求量，请重新输入！"<<endl;
// cout<<"****************************************************************"<<endl;
isRequestNeedOK = false;
continue;
}
if (Request[i]>Available[i])
{
cout<<"**************************当前运行结果*****************************"<<endl;
cout<<"您输入的请求进程的资源数量超过系统所供给的最大资源数量pi必须等待，请重新输入！"<<endl;
// cout<<"****************************************************************"<<endl;
isRequestAvailableOK = false;
continue;
}
}

for (int j = 0;j<m;j++)
{
Available[j] -=Request[j];
Allocation[chooseProcess][j] += Request[j];
Need[chooseProcess][j] -= Request[j];
}
cout<<"**********************************************************************"<<endl;

if (!isSystemSafe())   //如何不满足系统安全性算法，将本次试探作废，恢复到原来的值
{
for (int j = 0;j<m;j++)
{
Available[j] +=Request[j];
Allocation[chooseProcess][j] -= Request[j];
Need[chooseProcess][j] += Request[j];
}
//当请求向量Reque
cd43
st满足和Need、Available的关系时，证明系统已不能再分配资源
if (isRequestAvailableOK&&isRequestNeedOK)
{
cout<<"**************************当前运行结果*****************************"<<endl;
cout<<"当前可利用资源已经不能满足任何进程的需求，故系统进入不安全状态，系统不分配资源！"<<endl;
cout<<"****************************************************************"<<endl;
}

}

cout<<"尝试根据p(i)发出的请求向量后的资源情况："<<endl;
display();

cout<<"*******************************************************************"<<endl;
cout<<"是否继续输入请求变量request进行测试，是（Y）,否（N）"<<endl;
cout<<"isContinue = ";
cin>>isContinue;
if (isContinue=='Y'||isContinue=='y')
{
//input();//实现多次请求（保留上一次请求的状态）
continue;
}
else if (isContinue=='N'||isContinue=='n')
{
cout<<"******************************程序结束*****************************"<<endl;
break;
}

}
}

void display()
{
char processName[] = {'1','2','3','4','5','6'};

cout<<"----------------------------------------------------------------------"<<endl;
cout<<"当前进程个数为 n = "<<n<<endl;
cout<<"当前资源个数为 m = "<<m<<endl;
cout<<"系统可利用资源数情况如下："<<endl;
for (int i=0;i<m;i++)
{
cout<<setw(5)<<sourceName[i]<<" ";
}
cout<<endl;
cout<<setw(5)<<Available[0]<<" ";
cout<<setw(5)<<Available[1]<<" ";
cout<<setw(5)<<Available[2]<<" "<<endl;

cout<<"------------------------------------------------------------------------"<<endl;

cout<<"processName";
cout<<setw(10)<<"Max[][]"<<" ";
cout<<setw(15)<<"Allocation[][]"<<" ";
cout<<setw(10)<<"Need[][]"<<" ";
if (isDisplayAvaliable)
{
cout<<setw(15)<<"available[][]";
}
cout<<endl;
cout<<setw(15);
for (int i=0;i<m;i++)
{
cout<<sourceName[i]<<setw(3);
}

cout<<setw(5);
for (int i=0;i<m;i++)
{
cout<<sourceName[i]<<setw(3);
}

cout<<setw(10);
for (int i=0;i<m;i++)
{
cout<<sourceName[i]<<setw(3);
}

if (isDisplayAvaliable)
{
cout<<setw(5);
for (int i=0;i<m;i++)
{
cout<<sourceName[i]<<setw(3);
}
}
cout<<endl;

//设置矩阵输出形式
bool OnlyOneLineAvaliable = true;  //Avaliable数组只输出第一行
for (int i=0;i<n;i++)
{
cout<<setw(5)<<"P"<<processName[i];
cout<<setw(10);
for (int j = 0;j<m;j++)
{
cout<<Max[i][j]<<setw(3);
}

cout<<setw(5);
for (int j = 0;j<m;j++)
{
cout<<Allocation[i][j]<<setw(3);
}

cout<<setw(10);
for (int j = 0;j<m;j++)
{
cout<<Need[i][j]<<setw(3);
}

if (isDisplayAvaliable&&OnlyOneLineAvaliable)
{
cout<<setw(5);
for (int i=0;i<m;i++)
{
cout<<Available[i]<<setw(3);
}
OnlyOneLineAvaliable = false;
}
cout<<endl;
}

}

注：代码中的引用【#include "stdafx.h"】不是自己编写的程序哈。我这里的编译环境是VS2010，创建项目的时候选择的是【自动生成头文件】这样做生成的程序.cpp会自动引用
【#include "stdafx.h"】这个.h文件，而VS编译器里面会有这个文件。如果你用的是其他的编译器，你可以把这行引用去掉，自己重新创建一个project，把数据准备好，直接编译就行。