用银行家算法实现系统资源分配

最新推荐文章于 2024-05-01 18:08:38 发布

weixin_33725722

最新推荐文章于 2024-05-01 18:08:38 发布

阅读量1k

点赞数

文章标签：数据结构与算法测试操作系统

原文链接：http://blog.51cto.com/curley/803342

版权

银行家算法是 Dijkstra在1965年提出的一种避免死锁的算法。银行家算法陈述如下：

1) 当一个进程提出一个资源的请求时，假定分配给它，并调用检查系统状态安全性的算法。如果系统是安全的，则对申请者的假分配变为实际的分配。否则，推迟它的请求，让其阻塞等待。

2) 检查系统状态安全性的算法。根据系统剩余的资源情况，银行家进行检查，看满足请求者的要求后，是否仍是系统中的所有进程都能正常完成（即能找到一个进程完成序列）。若能，系统是安全的。否则，系统是不安全的。

银行家算法主要如下：

输入：资源个数 m、进程个数n、最大请求矩阵max、分配矩阵allocation

输出：进程运行情况和安全状况提示（如果安全，输出一个可能的进程完成序列）

主要算法：

1) 初始化，输入各个参数，初始化各变量

2) 判断系统安全性

程序中安全性算法的描述如下：

a. 设置如下两个工作向量：

Work：表示系统可提供给进程继续运行的各类资源的空闲资源数目，它含有m个元素，执行安全性算法开始时，Work＝Available。

Finish：表示系统是否有足够的资源分配给进程，使之运行完成。开始时，Finish[i]＝false;当有足够的资源分配给进程Pi时，令Finish[i]＝true。

b. 从进程集合中找到一个能满足下列条件的进程：

Finish[i]＝ false;

Need[i] <= Work;

如果找到了就执行步骤c，否则执行步骤d。

c. 当进程Pi获得资源后，可执行直到完成，并释放出分配给它的资源，故应执行

Work = Allocation[i]＋Work;

Finish[i]＝true;

然后转向b。

d. 若所有进程中的Finish[i]都是true，则表示系统处于安全状态；否则，系统处于不安全状态。

3) 当系统请求资源时，调用系统状态安全性算法

系统状态安全性算法：

当某一进程提出资源申请时，系统须做出判断，能否将所申请资源分配给该进程。设Request[i]是进程Pi的请求向量，Request[i][j]＝k表示进程Pi请求分配 j类资源有k个。当Pi发出资源请求后，系统按照下述步骤进行检查：

a. 如果Request[i]<= Need[i],则转向 b；否则出错，因为进程所需要的资源数已超过它所宣布的最大值；

b. 如果Request[i]<=Available，则转向步骤 c；否则，表示系统中尚无足够的资源满足进程Pi的申请，让进程Pi等待。

c. 假设系统把申请的资源分配给进程Pi，则对应下面的数据结构进行修改：

Available= Available－Request[i];

Allocation[i]= Allocation[i]＋Request[i];

Need[i]= Need[i]－Request[i];

d. 系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，就将资源分配给Pi，满足其资源申请要求；否则，让进程等待，并恢复原来的资源分配状态。

数据结构：

class bank

{

private:

int m; //资源数量

int n; //进程数量

int available[M]; //可利用资源向量

int max[M][N]; //最大需求矩阵

int allocation[M][N]; //分配矩阵

int need[M][N]; //需求矩阵

public:

bool Initilize(); //初始化各变量

bool IsSafe(); //检查系统是否安全

bool Resoure_allocate();//分配资源

bool IsFinish(); //检查系统是否运行完毕

};

测试用例：

本测试用例为《操作系统原理教程（第二版）》 P62页用例，先给P2分配一个打印机，分配成功，然后分配给P5一台打印机，分配失败，然后按照P4，P1，P5，P2，P3执行系统。

Available=（ 1,0,2,0）

进程	磁带机	绘图机	打印机	光驱
P1	3	0	1	1
P2	0	1	0	0
P3	1	1	1	0
P4	1	1	0	1
P5	0	0	0	0

进程当前的分配矩阵 Allocation

进程	磁带机	绘图机	打印机	光驱
P1	1	1	0	0
P2	0	1	1	2
P3	3	1	0	0
P4	0	0	1	0
P5	2	1	1	0

进程当前的剩余请求矩阵 Need

进程	磁带机	绘图机	打印机	光驱
P1	4	1	1	1
P2	0	2	1	2
P3	4	2	1	0
P4	1	1	1	1
P5	2	1	1	0

各个进程的最大请求矩阵 Max

测试数据：（直接复制到终端中即可）

4 1 1 1

0 2 1 2

4 2 1 0

1 1 1 1

2 1 1 0

3 0 1 1

0 1 0 0

1 1 1 0

1 1 0 1

0 0 0 0

1 0 2 0

运行结果：

输入资源数量： 4

输入进程数量： 5

输入最大请求矩阵 5X4

4 1 1 1

0 2 1 2

4 2 1 0

1 1 1 1

2 1 1 0

输入分配矩阵 5X4

3 0 1 1

0 1 0 0

1 1 1 0

1 1 0 1

0 0 0 0

输入可利用资源向量 1X4

1 0 2 0

安全序列是

3 0 1 2 4

输入运行进程号 :1

请求资源号： 2

请求数量： 1

安全序列是

3 0 1 2 4

输入运行进程号 :4

请求资源号： 2

请求数量： 1

没有安全序列

系统不安全，等待

输入运行进程号 :3

请求资源号： 2

请求数量： 1

安全序列是

0 1 2 4

进程 3运行完毕

输入运行进程号 :0

请求资源号： 0

请求数量： 1

安全序列是

0 1 2 4

输入运行进程号 :0

请求资源号： 1

请求数量： 1

安全序列是

1 2 4

进程 0运行完毕

输入运行进程号 :4

请求资源号： 0

请求数量： 2

安全序列是

1 2 4

输入运行进程号 :4

请求资源号： 1

请求数量： 1

安全序列是

4 1 2

输入运行进程号 :4

请求资源号： 2

请求数量： 1

安全序列是

1 2

进程 4运行完毕

输入运行进程号 :1

请求资源号： 1

请求数量： 1

安全序列是

1 2

输入运行进程号 :1

请求资源号： 3

请求数量： 2

安全序列是

进程 1运行完毕

输入运行进程号 :2

请求资源号： 0

请求数量： 3

安全序列是

输入运行进程号 :2

请求资源号： 1

请求数量： 1

安全序列是

进程 2运行完毕

所有进程执行完毕

#include <iostream>
#include <cstdlib>
#define M 16
#define N 16
using namespace std;
class bank
{
private:
int m; //资源数量
int n; //进程数量
int available[M]; //可利用资源向量
int max[M][N]; //最大需求矩阵
int allocation[M][N]; //分配矩阵
int need[M][N]; //需求矩阵
public:
bool Initilize(); //初始化各变量
bool IsSafe(); //检查系统是否安全
bool Resoure_allocate();//分配资源
bool IsFinish(); //检查系统是否运行完毕
};
int main()
{
bank process;
if (!process.Initilize()) //初始化
{
cout<<"输入错误"<<endl;
}
if (!process.IsSafe()) //检查系统运行初是否安全
{
return 0;
}
while (true)
{
process.Resoure_allocate(); //根据各进程需要分配资源
if (process.IsFinish()) //检查系统是否执行完毕
{
cout<<"所有进程执行完毕"<<endl;
break;
}
}
system("PAUSE");
return 0;
}
bool bank::Initilize()
{
int i,j;
cout<<"输入资源数量：";
cin>>m;
cout<<"输入进程数量：";
cin>>n;
cout<<"输入最大请求矩阵 "<<n<<"X"<<m<<endl;
for (i = 0; i < n; i++)
{
for (j = 0; j < m; j++)
{
cin>>max[i][j];
}
}
cout<<"输入分配矩阵 "<<n<<"X"<<m<<endl;
for (i = 0; i < n; i++)
{
for (j = 0; j < m; j++)
{
cin>>allocation[i][j];
}
}
for (i = 0; i < n; i++)
{
for (j = 0; j < m; j++)
{
need[i][j]=max[i][j]-allocation[i][j];
if (need[i][j] < 0)
{
return false;
}
}
}
cout<<"输入可利用资源向量 "<<1<<"X"<<m<<endl;
for (i = 0; i < m; i++)
{
cin>>available[i];
if (available[i] < 0)
{
return false;
}
}
return true;
}
bool bank::IsSafe()
{
int i,j,k,result[N],work[M],finish[N];
for (i = 0; i < m; i++)
{
work[i]=available[i];
}
for (i = 0; i < n; i++) //标识变量初始化
{
finish[i]=false;
}
for (i = 0, k = 0; i < n; i++)
{
if (!finish[i])
{
for (j = 0; j < m; j++)
{
if (need[i][j] > work[j]) //目前无法满足该进程
{
break;
}
}
if (j == m) //可以满足该进程
{
result[k++]=i;
for (j = 0; j < m; j++) //将现有可用资源数加上第i进程已经分配了的
{
work[j]+=allocation[i][j];
}
finish[i]=true;
i=-1; //从头扫描
}
}
}
for (i = 0; i < n; i++)
{
if (!finish[i])
{
cout<<"没有安全序列"<<endl;
return false;
}
}
cout<<"安全序列是"<<endl;
for (i = 0; i < n; i++)
{
for ( j = 0; j < m; j++) //如果进程已经执行完毕,则安全序列中不再输出
{
if (need[result[i]][j] != 0)
{
break;
}
}
if (j == m)
{
continue;
}
cout<<result[i]<<" ";
}
cout<<endl;
return true;
}
bool bank::Resoure_allocate()
{
int i,process_id,source_id,amount;
cout<<"输入运行进程号:";
cin>>process_id;
cout<<"请求资源号：";
cin>>source_id;
cout<<"请求数量：";
cin>>amount;
if (amount > need[process_id][source_id])
{
cout<<"请求不合法，终止运行"<<endl;
return false;
}
if (amount > available[source_id])
{
cout<<"请求无法满足，等待"<<endl;
return false;
}
available[source_id]-=amount; //假定分配资源
allocation[process_id][source_id]+=amount;
need[process_id][source_id]-=amount;
if (!IsSafe()) //检查系统是否安全
{
available[source_id]+=amount;
allocation[process_id][source_id]-=amount;
need[process_id][source_id]+=amount;
cout<<"系统不安全，等待"<<endl;
return false;
}
for ( i = 0; i < m; i++) //查看进程是否执行完毕
{
if (allocation[process_id][i] != max[process_id][i])
{
break;
}
}
if (i == m) //进程执行完毕
{
for ( i = 0; i < m; i++)
{
available[i]+=allocation[process_id][i];
allocation[process_id][i]=0;
need[process_id][i]=0;
}
cout<<"进程"<<process_id<<"运行完毕"<<endl;
}
return true;
}
bool bank::IsFinish()
{
int i,j,finish[N];
for ( i = 0; i < n; i++)
{
finish[i]=false;
}
for ( i = 0; i < n; i++)
{
for ( j = 0; j < m; j++)
{
if (need[i][j] != 0)
{
break;
}
}
if (j == m)
{
finish[i]=true;
}
}
for ( i = 0; i < n; i++)
{
if (finish[i] == false)
{
break;
}
}
if (i != n)
{
return false;
}
return true;
}

转载于:https://blog.51cto.com/curley/803342

weixin_33725722

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
用银行家算法实现系统资源分配

银行家算法是Dijkstra在1965年提出的一种避免死锁的算法。银行家算法陈述如下：1) 当一个进程提出一个资源的请求时，假定分配给它，并调用检查系统状态安全性的算法。如果系统是安全的，则对申请者的假分配变为实际的分配。否则，推迟它的请求，让其阻塞等待。2) 检查系统状态安全性的算法。根据系统剩余的资源情况，银行家进行检查，看满足请求者的要求后，是否仍...
复制链接

扫一扫