尼采般地抒情

公告栏

此网站主题为本人手写主题, 主题待开源···

站点信息

文章总数目: 298
已运行时间: 991
目录
  1. 一、银行家算法
  2. 二、代码实现

尼采般地抒情

尼采般地抒情

公告栏

此网站主题为本人手写主题, 主题待开源···

站点信息

文章总数目: 298
已运行时间: 991

一、银行家算法

功能:避免死锁

在银行中,客户申请贷款的数量是有限的,每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量,在满足所有贷款要求时,客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时,都应尽量满足客户的需要。在这样的描述中,银行家就好比操作系统,资金就是资源,客户就相当于要申请资源的进程。

二、代码实现

#include <iostream>

using namespace std;
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/_ 定义全局变量 _/
const int x = 50, y = 50; /_ x 为进程个数 y 为资源种类数 _/
int Available[y]; /_ 各资源可利用的数量 _/
int Allocation[x][y]; /_ 各进程当前已分配的资源数量 _/
int Max[x][y]; /_ 各进程对各类资源的最大需求数 _/
int Need[x][y]; /_ 尚需多少资源 _/
int Request[y]; /_ 申请多少资源 _/
int Work[y]; /_ 工作向量,表示系统可提供给进程继续运行所需的各类资源数量 _/
int Finish[x]; /_ 表示系统是否有足够的资源分配给进程,1 为是 _/
int p[x]; /_ 存储安全序列 _/
int i, j; /_ i 表示进程,j 表示资源 _/
int n, m; /_ n 为进程 i 的数量,m 为资源 j 种类数 _/
int l = 0; /_ l 用来记录有几个进程是 Finish[i]=1 的,当 l=n 是说明系统状态是安全的 _/
int counter = 0; /_ 记数器,记录可执行的进程数 _/
/_ 函数声明 _/
void chushihua(); /_ 初始化函数 _/

void safe(); /_ 安全性算法 _/

void show(); /_ 函数 show,输出当前状态 _/

void bank(); /_ 银行家算法 _/

void jieshu(); /_ 结束函数 _/

void chushihua()
{
cout << "输入进程的数量: "; /_ 从此开始输入有关数据 _/
cin >> n;
cout << "输入资源种类数: ";
cin >> m;
cout << endl << "输入各种资源当前可用的数量( " << m << " 种): " << endl;
for ( j = 0; j < m; j++ ) /_ m 为资源数 _/
{
cout << "输入资源 " << j << " 可利用的数量 Available[" << j << "]: ";
cin >> Available[j]; /_ 输入数字的过程 _/
Work[j] = Available[j]; /_ 初始化 Work[j],它的初始值就是当前可用的资源数 _/
}
cout << endl << "输入各进程当前已分配的资源数量 Allocation[" << n << "][" << m << "]: " << endl;
for ( i = 0; i < n; i++ ) /_ n 为进程数 _/
{
for ( j = 0; j < m; j++ ) /_ m 为资源数 _/
{
cout << " 输入进程 " << i << " 当前已分配的资源 " << j << " 数量: ";
cin >> Allocation[i][j];
}
cout << endl;
Finish[i] = 0; /_ 初始化 Finish[i] _/
}
cout << endl << "输入各进程对各类资源的最大需求 Max[" << n << "][" << m << "]: " << endl;
for ( i = 0; i < n; i++ ) /_ n 为进程数 _/
{
for ( j = 0; j < m; j++ ) /_ m 为资源数 _/
{
cout << " 输入进程 " << i << " 对资源 " << j << " 的最大需求数: ";
cin >> Max[i][j];
if ( Max[i][j] >= Allocation[i][j] ) /_ 若最大需求大于已分配,则计算需求量 _/
Need[i][j] = Max[i][j] - Allocation[i][j];
else
Need[i][j] = 0; /_ Max 小于已分配的时候,此类资源已足够不需再申请 _/
}
cout << endl;
}
cout << endl << "初始化完成" << endl;
}

/_ 安全性算法函数 _/
void safe()
{
l = 0; /_ l 用来记录有几个进程是 Finish[i]=1 的,当 l=n 是说明系统状态是安全的 _/
for ( i = 0; i < n; i++ ) /_ n 为进程数 _/
{
if ( Finish[i] == 0 )
{ /_ 逐个查找 Finish[i]==0 的进程 条件一 _/
counter = 0; /_ 记数器,记录有多少个进程已经执行 _/
for ( j = 0; j < m; j++ ) /_ m 为资源数 _/
{
if ( Work[j] >= Need[i][j] )
counter = counter + 1; /_ 可用大于需求,记数,该进程可以执行 _/
}
if ( counter == m ) /_ i 进程的每类资源都符合 Work[j]>=Need[i][j] 条件二 _/
{
p[l] = i; /_ 存储安全序列 _/
Finish[i] = 1; /_ i 进程标志为可分配 _/
for ( j = 0; j < m; j++ )
Work[j] = Work[j] + Allocation[i][j]; /_ 释放资源 _/
l = l + 1; /_ 记数,现在有 l 个进程是安全的,当 l=n 时说明满足安全序列 _/
i = -1; /_ 从第一个进程开始继续寻找满足条件一二的进程 _/
}
}
}
}

/_ 显示当前状态函数 _/
void show() /_ 函数 show,输出当前资源分配情况 _/
{
int i, j; /_ 局部变量,i 表示进程,j 表示资源 _/
int All[y]; /_ 各种资源的总数量 _/
int L1; /_ 局部变量 L1 _/
cout << "当前的状态为:" << endl;
cout << "各种资源的总数量:" << endl;
for ( j = 0; j < m; j++ ) /_ m 为资源数 _/
{
cout << " 资源" << j << ": ";
All[j] = Available[j]; /_ 总数量=可用的+已分配的 _/
for ( i = 0; i < n; i++ ) /_ n 为进程数 _/
All[j] += Allocation[i][j];
cout << All[j] << " ";
}
cout << endl << "当前各种资源可用的量为(available):" << endl;
for ( j = 0; j < m; j++ ) /_ m 为资源数 _/
cout << " 资源" << j << ": " << Available[j] << " ";
cout << endl << "各进程所需的最大资源量(Max): " << endl;
for ( i = 0; i < m; i++ ) /_ m 为资源数 _/
{
cout << " 资源" << i << " ";
}
cout << endl;
for ( L1 = 0; L1 < n; L1++ ) /_ n 为进程数 _/
{
cout << "进程" << L1 << ": ";
for ( j = 0; j < m; j++ )
cout << Max[L1][j] << " ";
cout << endl;
}
cout << endl << "各进程已经得到的资源量(allocation): " << endl;
for ( i = 0; i < m; i++ ) /_ m 为资源数 _/
{
cout << " 资源" << i << " ";
}
cout << endl;
for ( L1 = 0; L1 < n; L1++ ) /_ n 为进程数 _/
{
cout << "进程" << L1 << ": ";
for ( j = 0; j < m; j++ )
cout << Allocation[L1][j] << " ";
cout << endl;
}
cout << endl << "各进程还需要的资源量(need):" << endl;
for ( i = 0; i < m; i++ ) /_ m 为资源数 _/
{
cout << " 资源" << i << " ";
}
cout << endl;
for ( L1 = 0; L1 < n; L1++ )
{
cout << "进程" << L1 << ": ";
for ( j = 0; j < m; j++ )
cout << Need[L1][j] << " ";
cout << endl;
}
}

/_ 银行家算法函数 _/
void bank()
{
cout << endl << "进程申请分配资源:" << endl;
int k = 0; /_ 用于输入进程编号 _/
bool r = false; /_ 初值为假,输入 Y 继续申请则置为真 _/
do /_ 输入请求 _/
{
cout << "输入申请资源的进程(0-" << n - 1 << "): ";
cin >> k; /_ 进程编号 _/
cout << endl;
while ( k > n - 1 ) /_ 输入错误处理 _/
{
cout << endl << "无该进程号,重新输入:" << endl;
cout << endl << "输入申请资源的进程(0--" << n - 1 << "): ";
cin >> k; /_ 进程编号 _/
cout << endl;
}
cout << endl << "输入该进程申请各类资源的数量: " << endl;
for ( j = 0; j < m; j++ ) /_ m 为资源数 _/
{
do /_ do……while 循环判断申请输入的情况 _/
{
cout << "进程 " << k << " 申请资源[" << j << "]的数量:";
cin >> Request[j]; /_ 输入请求进程数 _/
cout << endl;
if ( Request[j] > Need[k][j] ) /_ 申请大于需求量时出错,提示重新输入 cout<<"申请量大于需要量!"<<endl; _/
{
cout << "申请的资源" << j << "的数量为" << Request[j] << ",大于进程" << k << "对该资源需求量" << Need[k][j] << "。" << endl;
cout << "重新输入!" << endl;
}
/_ 先判断是否申请大于需求量,再判断是否申请大于可利用量 _/
else if ( Request[j] > Available[j] ) /_ 申请大于可利用量, 应该阻塞等待 _/
{
cout << "\n 没有那么多资源,目前可利用资源" << j << "数量为" << Available[j] << ",本次申请不成功,进程等待!" << endl;
Finish[k] = 0; /_ 该进程等待 _/
goto error; /_ goto 语句跳转,结束本次申请 _/
}
}
while ( Request[j] > Need[k][j] ); /_ Request[j]>Available[j] _/
}
/_ 改变 Available、Allocation、Need 的值 _/
for ( j = 0; j < m; j++ ) /_ m 为资源数 _/
{
Available[j] = Available[j] - Request[j]; /_ 可用的资源数=可用的资源数-请求分配的资源数 _/
Allocation[k][j] = Allocation[k][j] + Request[j]; /_ 已分配的资源数=已分配的资源数+请求的资源数 _/
Need[k][j] = Need[k][j] - Request[j]; /_ 还需要的资源数=还需要的资源数-请求的资源数 _/
Work[j] = Available[j];
}
safe(); /_ 调用安全性算法函数,判断当前状态的安全性 _/
if ( l < n ) /_ l 用来记录有几个进程是 Finish[i]=1 的,当 l=n 是说明系统状态是安全的 _/
{
l = 0;
cout << "\n 试分配后,状态不安全,所以不予分配!恢复原状态" << endl;
/_ 恢复数据 _/
for ( j = 0; j < m; j++ ) /_ m 为资源数 _/
{
Available[j] = Available[j] + Request[j];
Allocation[k][j] = Allocation[k][j] - Request[j];
Need[k][j] = Need[k][j] + Request[j];
Work[j] = Available[j];
}
for ( i = 0; i < n; i++ ) /_ n 为进程数 _/
Finish[i] = 0; /_ 进程均置为未分配状态 _/
}else { /_ l=n,即所有的 Finish[i]=1,每一个进程均能执行 _/
l = 0; /_ 判断标志 _/
cout << "\n 申请资源成功!!!" << endl;
for ( j = 0; j < m; j++ ) /_ m 为资源数 _/
{
if ( Need[k][j] == 0 )
;
else { /_有一种资源还没全部申请到,则该进程不可执行,不能释放拥有的资源 _/
l = 1; /_ 置 l 为 1,作为判断标志 _/
break;
}
}
if ( l != 1 ) /_ 进程可以执行,则释放该进程的所有资源 _/
{
for ( j = 0; j < m; j++ ) /_ m 为资源数 _/
{
Available[j] = Available[j] + Allocation[k][j];
Allocation[k][j] = 0;
}
cout << "该进程已得到所有需求资源,执行后将释放其所有拥有资源!" << endl;
}
l = 0; /_ 归零 _/
cout << "\n 安全的状态!" << endl;
cout << "安全序列为: ";
cout << endl << "进程" << "(" << p[0] << ")"; /_ 输出安全序列,考虑显示格式,先输出第一个 _/
Finish[0] = 0;
for ( i = 1; i < n; i++ )
{
cout << "==>>" << "进程" << "(" << p[i] << ")";
Finish[i] = 0; /_ 所有进程置为未分配状态 _/
}
cout << endl << endl;
}
show(); /_ 显示当前状态 _/
error: /_ 申请大于可利用量, 应该阻塞等待,结束本次资源申请,GOTO 语句跳转至此 _/
cout << endl << "是否继续申请资源(y/n)或(Y/N)?";
char* b = new char; /* 输入 y/n,判断是否继续申请 <<endl */
cin >> b;
cout << endl;
cout << "-------------------------------------------" << endl << endl;
cout << endl;
if ( *b == 'y' || _b == 'Y' )
r = true; /_ 继续申请 */
else{
r = false; /*不继续申请 _/
jieshu(); /_ 调用结束函数 \*/
}
}
while ( r == true );
}

/_ 结束函数 _/
void jieshu()
{
cout << endl << endl;
cout << "\t\t 演示计算完毕" << endl;
cout << endl << endl;
}

/_ 主函数 _/
int main()
{
cout << endl << endl << "\t\t\t\t 模拟银行家算法" << endl << endl;
chushihua(); /_ 初始化函数调用 _/
cout << endl;
show(); /_ 输出当前状态 _/
safe(); /_ 判断当前状态的安全性 _/
if ( l < n ) /_ l 在 safe 中是用来记录安全的进程的个数的 _/
{
cout << "\n 当前状态不安全,拒绝申请!" << endl;
cout << endl;
return(0);
}else {
int i; /_ 局部变量 _/
l = 0;
cout << endl << "\n 当前的状态是安全的!安全序列为:" << endl;
cout << "进程" << "(" << p[0] << ")"; /_ 输出安全序列 _/
for ( i = 1; i < n; i++ )
cout << "->>" << "进程" << "(" << p[i] << ")";
for ( i = 0; i < n; i++ )
Finish[i] = 0; /_ 所有进程置为未分配状态 _/
cout << endl;
}
bank(); /_ 调用银行家算法函数 _/
cout << "\t\t 演示计算完毕" << endl;
return(0);
}

评论区

Twikoo giscus