操作系统实验2 银行家算法
1.目的和要求
银行家算法(Banker’s Algorithm)是一个避免死锁(Deadlock)的著名算法,是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础,判断并保证系统的安全运行。
2.实验内容
①数据结构:
- 可利用资源向量Availabl。是个含有m个元素的数组,其中的每一个元素代表一类可利用的资源数目。如果Available[j]=K,则表示系统中现有Rj类资源K个。
2)最大需求矩阵Max。这是一个n×m的矩阵,它定义了系统中n个进程中的每一个进程对m类资源的最大需求。如果Max[i,j]=K,则表示进程i需要Rj类资源的最大数目为K。
3)分配矩阵Allocation。这也是一个n×m的矩阵,它定义了系统中每一类资源当前已分配给每一进程的资源数。如果Allocation[i,j]=K,则表示进程i当前已分得Rj类资源的 数目为K。
4)需求矩阵Need。这也是一个n×m的矩阵,用以表示每一个进程尚需的各类资源数。如果Need[i,j]=K,则表示进程i还需要Rj类资源K个,方能完成其任务。Need[i,j]=Max[i,j]-Allocation[i,j]。
②银行家算法。
在避免死锁的方法中,所施加的限制条件较弱,有可能获得令人满意的系统性能。在该方法中把系统的状态分为安全状态和不安全状态,只要能使系统始终都处于安全状态,便可以避免发生死锁。
银行家算法的基本思想是分配资源之前,判断系统是否是安全的;若是,才分配。它是最具有代表性的避免死锁的算法。
设进程cusneed提出请求REQUEST [i],则银行家算法按如下规则进行判断。
(1)如果REQUEST [cusneed] [i]<= NEED[cusneed][i],则转(2);否则,出错。
(2)如果REQUEST [cusneed] [i]<= AVAILABLE[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=Work+ALLOCATION;
Finish=true;
GOTO 2
(4)如所有的进程Finish= true,则表示安全;否则系统不安全。
3.实验环境
①PC兼容机
②Windows、DOS系统、Turbo c 2.0
③C语言
4.实验程序
流程图
#include <iostream>
using namespace std;
#define MAXPROCESS 50 //最大进程数
#define MAXRESOURCE 100 //最大资源数
int AVAILABLE[MAXRESOURCE]; //可用资源数组
int MAX[MAXPROCESS][MAXRESOURCE]; //最大需求矩阵
int ALLOCATION[MAXPROCESS][MAXRESOURCE]; //分配矩阵
int NEED[MAXPROCESS][MAXRESOURCE]; //需求矩阵
int REQUEST[MAXPROCESS][MAXRESOURCE]; //进程需要资源数
bool FINISH[MAXPROCESS]; //系统是否有足够的资源分配
int p[MAXPROCESS]; //记录序列
int m,n; //m个进程,n个资源
void Init(); //初始化变量
bool Safe(); //安全检测
void Bank(); //银行家算法
void showdata(int,int); //显示输出系统信息
int main()
{
Init();
Safe();
Bank();
}
/*初始化变量*/
void Init()
{
int i,j;//输入进程
cout << "请输入进程的数目:";
cin >> m;//m为进程数目
cout << "请输入资源的种类:";
cin >> n;//有n中资源
cout << "请输入每个进程最多所需的各资源数,按照" << m << "x" << n << "矩阵输入" << endl;
for(i=0;i<m;i++)//通过循环,输入了每个进程的各类资源最大需求量MAX
for(j=0;j<n;j++)
cin >> MAX[i][j];
cout << "请输入每个进程已分配的各资源数,也按照" << m << "x" << n << "矩阵输入" << endl;
for(i = 0; i < m; i++)//输入每个进程的各类资源已分配量
for(j = 0; j < n; j++)
{
cin >> ALLOCATION[i][j];
NEED[i][j] = MAX[i][j] - ALLOCATION[i][j];//还需要的各类资源数目=最大需求-已经获得的
if(NEED[i][j] < 0)//若已经获得的>最大需求量,则需要重新输入,Allocation
{
cout << "您输入的第" << i+1 << "个进程所拥有的第" << j+1 << "个资源数错误,请重新输入:" << endl;
j--;
continue;
}
}
cout << "请输入各个资源现有的数目:" << endl;
for(i = 0; i < n; i++)//现有的各类资源数目
cin >> AVAILABLE[i];
}
/*银行家算法*/
void Bank()
{
int i,cusneed,flag = 0; //cousneed资源进程号
char again; //键盘录入一个字符用于判断是否继续请求资源
while(1)
{
showdata(n,m);//得到n和m
cout << endl;
/*请求资源*/
while(true)
{
cout << "请输入要申请资源的进程号(注:第1个进程号为0,依次类推)" << endl;
cin >> cusneed;//输入哪个进程需要请求资源
if (cusneed > m)//如果编程号>现有的进程数 ,则是输入的进程编号错误
{
cout << "没有该进程,请重新输入" << endl;
continue;
}
cout << "请输入进程所请求的各资源的数量" << endl;
for(i = 0; i < n; i++)//输入请求的各类资源数
cin >> REQUEST[cusneed][i];
for(i = 0; i < n; i++)
{
if(REQUEST[cusneed][i] > NEED[cusneed][i]) //如果用户选择的线程的第i个资源请求数>该线程该资源所需的数量
{
cout << "您输入的请求数超过进程的需求量!请重新输入!" << endl;
continue;
}
if(REQUEST[cusneed][i] > AVAILABLE[i]) //如果用户选择的线程的第i个资源请求数>系统现有的第i个资源的数量
{
cout << "您输入的请求数超过系统有的资源数!请重新输入!" << endl;
continue;
}
}
break;
}
/*如果请求合理,那么开始银行家算法计算*/
/*先将申请的资源进行分配*/
for(i = 0; i < n; i++)
{
AVAILABLE[i] -= REQUEST[cusneed][i]; //系统可用资源减去申请了的
ALLOCATION[cusneed][i] += REQUEST[cusneed][i]; //线程被分配的资源加上已申请了的
NEED[cusneed][i] -= REQUEST[cusneed][i]; //线程还需要的资源减去已申请得到的
}
/*判断分配申请资源后的系统是否安全;如果不安全则将分配的申请资源还回系统*/
if(Safe()) //AVAILABLE ALLOCATION NEED变动之后,是否会导致不安全
cout << "同意分配请求!" << endl;
else
{
cout << "您的请求被拒绝!" << endl;
/*资源还回系统*/
for(i = 0; i < n; i++)//拒绝后,已获得资源,需求和现有各类资源情况变化
{
AVAILABLE[i] += REQUEST[cusneed][i];
ALLOCATION[cusneed][i] -= REQUEST[cusneed][i];
NEED[cusneed][i] += REQUEST[cusneed][i];
}
}
/*对进程的需求资源进行判断;是否还需要资源;即NEED数组是否为0*/
for (i = 0; i < n; i++)//计算已经不需要资源的进程有多少个
if (NEED[cusneed][i] <= 0)
flag++;
if (flag == n) //如果该进程各资源都已满足条件,则释放资源
{
for (i = 0; i < n; i++)//释放资源
{
AVAILABLE[i] += ALLOCATION[cusneed][i];
ALLOCATION[cusneed][i] = 0;
NEED[cusneed][i] = 0;
}
cout << "线程" << cusneed << " 占有的资源被释放!" << endl;
flag = 0;
}
for(i = 0; i < m; i++) //分配好了以后将进程的标识FINISH改成false
FINISH[i] = false;
/*判断是否继续申请*/
cout << "您还想再次请求分配吗?是请按y/Y,否请按其它键" << endl;
cin >> again;
if(again == 'y' || again == 'Y')
continue;
break;
}
}
/*安全性算法*/
//要找到一个安全序列
bool Safe()
{
int i, j, k, l = 0;
int Work[MAXRESOURCE]; //工作数组
/*工作数组赋值,与AVAILABLE数组相同*/
for (i = 0; i < n; i++)//将Available的值赋给work
Work[i] = AVAILABLE[i];
/*FINISH数组赋值,初始为全部false*/
for (i = 0; i < m; i++)
FINISH[i] = false; //FINISH记录每个进程是否安全
while (l < m) //正常的话,共执行m次
{
int init_index = l;
for (i = 0; i < m; i++)
{
if (FINISH[i] == true) //如果这个进程安全则继续下一个循环
continue;
for (j = 0; j < n; j++)
if (NEED[i][j] > Work[j])//若需求>work,则现在不能是这个进程
break;
if (j == n)
{
FINISH[i] = true;
for (k = 0; k < n; k++)
Work[k] += ALLOCATION[i][k];
p[l++] = i;//记录进程号
}
else //如果超过继续循环下一个进程
continue;
}
if (l==init_index)
{
cout << "系统是不安全的" << endl;
return false;
}
}
cout << "系统是安全的" << endl;
cout << "安全序列:" << endl;
for (i = 0; i < l; i++)
{
cout << p[i];
if (i != l - 1)
cout << "-->";
}
cout << endl;
return true;
}
/*显示*/
void showdata(int n,int m)
{
int i,j;
cout << endl << "-------------------------------------------------------------" << endl;
cout << "系统可用的资源数为: ";
for (j = 0; j < n; j++)
cout << " " << AVAILABLE[j];
cout << endl << "各进程还需要的资源量:" << endl;
for(i = 0; i < m; i++)
{
cout << " 进程" << i << ":";
for(j = 0; j < n; j++)
cout << " " << NEED[i][j];
cout << endl;
}
cout << endl << "各进程已经得到的资源量: " << endl << endl;
for (i = 0; i < m; i++)
{
cout << " 进程" << i << ":";
for (j = 0; j < n; j++)
cout << " " << ALLOCATION[i][j];
cout << endl;
}
cout << endl;
}
4.2实践一
在银行家算法中,若出现下述资源分配情况,试问:
1)该状态是否安全?
2)若进程P2提出请求Request(1,2,2,2)后,系统能否将资源分配?
4.2.1数学运算过程
解:
1)
资源分配情况:
进行安全检查:
经过安全检查,存在一个安全系列{P0,P3,P1,P2,P4},所以系统是安全的。
2)
P2提出请求Request(1,2,2,2)后,资源变化情况如下所示
Request(1,2,2,2)<Available(1,6,2,2);
Request(1,2,2,2)<Need(2,3,5,6)
所以先假定分配这个P2请求的资源,资源变化情况如下所示
Available=Available-Request=(0,4,0,0)
Need=Need-Request=(1,1,3,4)
Allocation=Allocation+Request=(2,5,7,6)
此时不存在一个安全序列,所以不能将P2请求的资源分配给它,让P2等待。
4.2.2代码运行结果截图