银行家算法

最新推荐文章于 2022-11-23 17:00:49 发布
最新推荐文章于 2022-11-23 17:00:49 发布
阅读量622 收藏 2
点赞数
分类专栏： 自考 文章标签： stm32 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q844258542/article/details/121472639
版权 
#include "stdafx.h"
#include <stdlib.h>
#include <iostream>
#include <iomanip>

using namespace std;

//测试数据
//请输入参与的进程数量：4
//请输入参与的资源数量：3
//请输入系统中A资源的数量：9
//请输入系统中B资源的数量：3
//请输入系统中C资源的数量：6
//请输入各进程对各资源的最大需求量：
//3 2 2 6 1 3 3 1 4 4 2 2
//请输入各进程当前已分得各资源的数量：
//1 0 0 5 1 1 2 1 1 0 0 2

int n=100; // 进程数
int m=100; // 资源种类数
int Available[100]={0};     // 可用资源
int Max[100][100]={0};        // 最大需求
int Allocation[100][100]={0}; // 已分得资源
int Need[100][100]={0};       // 需求矩阵
int Work[100]={0};          // 工作向量
bool Finish[100]={0};       // 是否满足
int Request[100]={0};       // 请求资源
char Name[100]={0};     // 资源名称 eg:A B C ...
int P=0;                // 请求资源的进程

void init();
bool safeCheck(bool flag);
void printTable();
void recoverSafe();
void bankerMethod();

// 初始化进程和资源
void init()
{
    cout << "请输入参与的进程数量：";
    cin >> n;
    cout << "请输入参与的资源数量：";
    cin >> m;
    for(int i=0;i<26;i++)
    {
        Name[i]=i+65;
    }
    for(int j=0;j<m;j++)
    {
        //cout << "请输入第" << i+1 << "个资源的名称：";
        //cin >> Name[i];
        cout << "请输入系统中" << Name[j] << "资源的数量：";
        cin >> Available[j];
    }
    cout << "请输入各进程对各资源的最大需求量：" << endl;
    for(int k=0;k<n;k++)
        for(int l=0;l<m;l++)
            cin >> Max[k][l];
    cout << "请输入各进程当前已分得各资源的数量：" << endl;
    for(int i1=0;i1<n;i1++)
        for(int j=0;j<m;j++)
            cin >> Allocation[i1][j];
    for(int i2=0;i2<n;i2++)
        for(int j=0;j<m;j++)
            Need[i2][j]=Max[i2][j]-Allocation[i2][j];
    // 初始化Available
    for(int i3=0;i3<n;i3++)
        for(int j=0;j<m;j++)
            Available[j]=Available[j]-Allocation[i3][j];
    // 初始化Work
    recoverSafe();
}

// 安全性检查
bool safeCheck(bool flag)
{
    //cout << "---DATA---|" << "----Work---|" << "----Need---|" << "-Allocation|" << "Work+Allocation|" << "--Finish--|" << endl;
      //cout << "-RESOURCE-|" << "--A--B--C--|" << "--A--B--C--|" << "--A--B--C--|" << "---A---B---C---|" << endl;
    cout << "---DATA---|" << setfill(' ') << setw(3*m+2) << "Work" << "|" << setw(3*m+2) << "Need" << "|" << setw(3*m+2) << "Allocation" << "|" << setw(3*m+2) << "Work+Allo" << "|" << "Finish|" << endl;
    
    cout << "-RESOURCE-|";

    for(int i=0;i<m;i++)
        cout << "--" << Name[i];
    cout << "--|";
    for(int i1=0;i1<m;i1++)
        cout << "--" << Name[i1];
    cout << "--|";
    for(int i2=0;i2<m;i2++)
        cout << "--" << Name[i2];
    cout << "--|";
    for(int i3=0;i3<m;i3++)
        cout << "--" << Name[i3];
    cout << "--|" << endl;

    number0:
    for(int i4=0;i4<n;i4++)
    {
        int count=0;
        for(int j=0;j<m;j++)
        {
            if(!Finish[i4] && Need[i4][j]<=Work[j])
            {
                count++;
            }
            if(count==m)
            {
                cout << "----P" << i4 << "----|";
                for(int k=0;k<m;k++)
                    cout << "-" << setw(2) << Work[k];
                cout << "--|";
                for(int k1=0;k1<m;k1++)
                    cout << "-" << setw(2) << Need[i4][k1];
                cout << "--|";
                for(int k2=0;k2<m;k2++)
                    cout << "-" << setw(2) << Allocation[i4][k2];
                cout << "--|";

                for(int k3=0;k3<m;k3++)
                {
                    Work[k3]=Work[k3]+Allocation[i4][k3];
                }
                Finish[i4]=true;

                for(int k4=0;k4<m;k4++)
                    cout << "-" << setw(2) << Work[k4];
                cout << "--|";
                cout << "--" << Finish[i4] << "--|";
                cout << endl;
                goto number0;
            }
        }
    }
    for(int i5=0;i5<n;i5++)
    {
        if(!Finish[i5])
        {
            flag=false;
            break;
        }
    }
    if(flag)
    {
        cout << "**系统处于安全状态**" << endl;
        return true;
    }
    else
    {
        cout << "**系统处于不安全状态**" << endl;
        return false;
    }
}

// 打印进程请求后资源分配表
void printTable()
{
    cout << "---DATA---|" << setw(4*m) << "Max" << "|" << setw(4*m) << "Allocation" << "|" << setw(4*m) << "Need" << "|" << setw(4*m) << "Available" << "|" << endl;
    
    cout << "-RESOURCE-|";

    for(int i=0;i<m;i++)
        cout << "-" << Name[i] << "--";
    cout << "|";
    for(int i1=0;i1<m;i1++)
        cout << "-" << Name[i1] << "--";
    cout << "|";
    for(int i2=0;i2<m;i2++)
        cout << "-" << Name[i2] << "--";
    cout << "|";
    for(int i3=0;i3<m;i3++)
        cout << "-" << Name[i3] << "--";
    cout << "|" << endl;

    for(int i4=0;i4<n;i4++)
    {
        cout << "---P" << i4 << "-----|";
        for(int j=0;j<m;j++)
        {
            cout << "-" << setfill('0') << setw(2) << Max[i4][j] << "-";
        }
        cout << "|";
        for(int j1=0;j1<m;j1++)
        {
            cout << "-" << setfill('0') << setw(2) << Allocation[i4][j1] << "-";
        }
        cout << "|";
        for(int j2=0;j2<m;j2++)
        {
            cout << "-" << setfill('0') << setw(2) << Need[i4][j2] << "-";
        }
        cout << "|";
        if(i4==0)
        {
            for(int j3=0;j3<m;j3++)
                cout << "-" << setfill('0') << setw(2) << Available[j3] << "-";
            cout << "|";
        }
        cout << endl;
    }
}

// 安全性检查后，恢复Work向量和Finish向量
void recoverSafe()
{
    // 恢复Work
    for(int i=0;i<m;i++)
        Work[i]=Available[i];
    for(int i1=0;i1<n;i1++)
        Finish[i1]=false;
}

// 银行家算法
void bankerMethod()
{
    // 客户端提示
    cout << "请输入需要请求资源的进程编号(int型)：" << endl;
    for(int i=0;i<n;i++)
    {
        cout << setfill(' ') << setw(3) << "P" << i << ": " << i << endl;
    }
    // 检查输入合法性
    int tmpP=-1;
    bool flagP=false;
    while(!flagP){
        cout << "进程编号:";
        scanf("%d",&tmpP);
        if(tmpP<0 || tmpP>=n){
            cout << "此进程不存在，请重新输入！" << endl;
            flagP=false;
            //防止不断循环
            while (getchar()!='\n');
        } else {
            P=tmpP;
            flagP=true;
        }
    }

    // 确认请求资源Request
    for(int i1=0;i1<m;i1++)
    {
        cout << "请输入进程P" << P << "请求的" << Name[i1] << "资源的数量：";
        cin >> Request[i1];
    }

    // 1.判断进程请求数量是否小于需求最大数量
    bool flag=true;
    int countRN=0;
    for(int i2=0;i2<m;i2++)
    {
        if(Request[i2]<=Need[P][i2])
            countRN++;
        if(countRN==m)
            flag=true;
        else
            flag=false;
    }
    if(flag)
    {
        // 2.判断进程请求数量是否小于系统可用数量
        int countRA=0;
        for(int i=0;i<m;i++)
        {
            if(Request[i]<=Available[i])
                countRA++;
            if(countRA==m)
                flag=true;
            else
                flag=false;
        }
        if(flag)
        {
            // 3.系统试探着把资源分配给进程
            for(int i=0;i<m;i++){
                Available[i]=Available[i]-Request[i];
                Allocation[P][i]=Allocation[P][i]+Request[i];
                Need[P][i]=Need[P][i]-Request[i];
                Work[i]=Work[i]-Request[i];
            }
            // T0时刻的资源分配表
            cout << "-----------------------为P" << P << "分配资源后的资源分配表------------------------" << endl;
            printTable();
            // 4.安全性算法
            cout << "------------------------P" << P << "申请资源时的安全性检查-------------------------" << endl;
            flag=safeCheck(flag);

            // 如果安全性检查不通过，则回收进程请求的资源
            if(!flag)
            {
                for(int i=0;i<m;i++){
                    Available[i]=Available[i]+Request[i];
                    Allocation[P][i]=Allocation[P][i]-Request[i];
                    Need[P][i]=Need[P][i]+Request[i];
                    Work[i]=Work[i]+Request[i];
                }
            }
            recoverSafe();
        }
        else
            cout << "**系统中没有足够资源**" << endl;
    }
    else
        cout << "**请求已超出进程P" << P << "需求最大值**" << endl;
}

int main(int argc, char* argv[])
{
    // 初始化进程和资源
    cout << "********************************初始化进程和资源********************************" << endl;
    init();
    cout << "**********************************初始化已完成**********************************" << endl;
    
    // T0时刻的资源分配表
    cout << "---------------------------T0时刻的资源分配表----------------------------" << endl;
    printTable();

    // T0时刻的安全性检查
    cout << "---------------------------T0时刻的安全性检查----------------------------" << endl;
    // 恢复安全性检查向量
    recoverSafe();

    // 银行家算法
    while(true)
    {
        cout << "是否要继续请求资源(y/n):" << endl;
        char ynRequest;
        cin >> ynRequest;
        if(ynRequest=='n' || ynRequest=='N')
            break;
        bankerMethod();
    }

    return 0;
}

银行家算法中使用到的数据结构

  1. 可利用资源数组(Available)
  2. 进程最大需求矩阵(Max)
  3. 分配矩阵(Allocation)
  4. 需求矩阵(Need)

总体步骤

  1. 如果request < need 则转向步骤2，否则出错，因为进程所申请的资源数已经超过了它所需要的资源数。
  2. 如果request < available 则转向步骤3，否则，表示系统中没有足够的资源满足进程pi的申请，pi必须等待。
  3. 尝试把系统的资源分配给pi，并修改下面数据结构中的数值

Available[i]=Available[i]-Request[i];

Allocation[P][i]=Allocation[P][i]+Request[i];

Need[P][i]=Need[P][i]-Request[i];

  1. 系统执行安全性检测算法，检查此次尝试分配后，系统是否处于安全状态。如果安全，则正是把资源分配给进程pi，完成本次分配；否则将尝试是分配作废，系统恢复原来资源分配的状态，让pi等待。

安全性检查步骤

  1. .设两个数组work 和 finish，其中

work表示系统可提供给进程继续运行的各类资源的空闲数目，它包含m个元素，执行安全算法开始时，work[i]= available[i]。

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

  1. .从进程集合中找出资源满足下述条件的进程：

finish[i]=false；Need[i] < work;

如果找到，则执行步骤（3），否则执行步骤（4）

  1. .当进程pi获得资源后，可顺利执行知道完毕，并释放出分配给它的资源，所以应执行：

Work[i] = Work[i] + Allocation[i];

Finish[i] = true;

goto Step 2;

  1. .如果所有进程的Finish都为True，则表示系统处于安全状态；否则表示系统处于不安全状态。

程序执行结果

********************************初始化进程和资源********************************

请输入参与的进程数量：4

请输入参与的资源数量：3

请输入系统中A资源的数量：9

请输入系统中B资源的数量：3

请输入系统中C资源的数量：6

请输入各进程对各资源的最大需求量：

3 2 2 6 1 3 3 1 4 4 2 2

请输入各进程当前已分得各资源的数量：

1 0 0 5 1 1 2 1 1 0 0 2

**********************************初始化已完成**********************************

---------------------------T0时刻的资源分配表----------------------------

---DATA---|         Max|  Allocation|        Need|   Available|

-RESOURCE-|-A---B---C--|-A---B---C--|-A---B---C--|-A---B---C--|

---P0-----|-03--02--02-|-01--00--00-|-02--02--02-|-01--01--02-|

---P1-----|-06--01--03-|-05--01--01-|-01--00--02-|

---P2-----|-03--01--04-|-02--01--01-|-01--00--03-|

---P3-----|-04--02--02-|-00--00--02-|-04--02--00-|

---------------------------T0时刻的安全性检查----------------------------

是否要继续请求资源(y/n):

y

请输入需要请求资源的进程编号(int型)：

  P0: 0

  P1: 1

  P2: 2

  P3: 3

进程编号:3

请输入进程P3请求的A资源的数量：1

请输入进程P3请求的B资源的数量：1

请输入进程P3请求的C资源的数量：0

-----------------------为P3分配资源后的资源分配表------------------------

---DATA---|         Max|  Allocation|        Need|   Available|

-RESOURCE-|-A---B---C--|-A---B---C--|-A---B---C--|-A---B---C--|

---P0-----|-03--02--02-|-01--00--00-|-02--02--02-|-00--00--02-|

---P1-----|-06--01--03-|-05--01--01-|-01--00--02-|

---P2-----|-03--01--04-|-02--01--01-|-01--00--03-|

---P3-----|-04--02--02-|-01--01--02-|-03--01--00-|

------------------------P3申请资源时的安全性检查-------------------------

---DATA---|       Work|       Need| Allocation|  Work+Allo|Finish|

-RESOURCE-|--A--B--C--|--A--B--C--|--A--B--C--|--A--B--C--|

**系统处于不安全状态**

是否要继续请求资源(y/n):

y

请输入需要请求资源的进程编号(int型)：

  P0: 0

  P1: 1

  P2: 2

  P3: 3

进程编号:1

请输入进程P1请求的A资源的数量：1

请输入进程P1请求的B资源的数量：0

请输入进程P1请求的C资源的数量：1

-----------------------为P1分配资源后的资源分配表------------------------

---DATA---|         Max|  Allocation|        Need|   Available|

-RESOURCE-|-A---B---C--|-A---B---C--|-A---B---C--|-A---B---C--|

---P0-----|-03--02--02-|-01--00--00-|-02--02--02-|-00--01--01-|

---P1-----|-06--01--03-|-06--01--02-|-00--00--01-|

---P2-----|-03--01--04-|-02--01--01-|-01--00--03-|

---P3-----|-04--02--02-|-00--00--02-|-04--02--00-|

------------------------P1申请资源时的安全性检查-------------------------

---DATA---|       Work|       Need| Allocation|  Work+Allo|Finish|

-RESOURCE-|--A--B--C--|--A--B--C--|--A--B--C--|--A--B--C--|

----P1----|- 0- 1- 1--|- 0- 0- 1--|- 6- 1- 2--|- 6- 2- 3--|--1--|

----P0----|- 6- 2- 3--|- 2- 2- 2--|- 1- 0- 0--|- 7- 2- 3--|--1--|

----P2----|- 7- 2- 3--|- 1- 0- 3--|- 2- 1- 1--|- 9- 3- 4--|--1--|

----P3----|- 9- 3- 4--|- 4- 2- 0--|- 0- 0- 2--|- 9- 3- 6--|--1--|

**系统处于安全状态**

是否要继续请求资源(y/n):

帅子o
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统—银行家算法（C++实现，资源种类、进程、数资源数不固定）
05-25
银行家算法 ：用户输入资源种类、进程、数资源数，再输入所需分配进程的编号以及资源个数，经过系统安全检查，判断是否安全，安全则分配成功，输出安全序列；不安全则分配失败 语言：C++ 运行环境：Visual Studio 2013/更高版本 备注：资源种类、进程、数资源数不固定，待用户输入
线程死锁
zhangrrrr的博客
07-18 441
死锁,线程死锁
操作系统 银行家算法 安全性检查
今晚看星星的博客
11-22 5118
文章目录算法描述银行家算法安全性检查数据结构安全性算法银行家算法主函数测试用例 算法描述 银行家算法 设进程I提出请求Request[N]，则银行家算法按如下规则进行判断 如果Request[N]<= Need [I, N]，则转(2)；否则，出错 如果Request[N]<= Available，则转(3)；否则，出错 系统试探分配资源，修改相关数据： Available = Available -Request Allocation = Allocation +Request Need
操作系统实验七(银行家算法)
zyz博客
04-22 1675
参考代码： #include <stdio.h> #include <stdlib.h> #include <stdbool.h> //bool类型数据头函数 #include <iostream> using namespace std; #define processNum 5 //五个进程 #define res...
使用java实现银行家算法
08-25
"使用Java实现银行家算法" 银行家算法是操作系统中的一种资源分配算法，用于避免死锁和饥饿现象。该算法的主要思想是，系统中有多个资源和进程，进程需要请求资源来执行任务，系统需要确保资源的分配是安全的，即...
银行家算法模拟_银行家算法_
09-29
《银行家算法模拟详解及其C语言实现》 在操作系统领域，银行家算法是一种经典的资源分配策略，用于预防死锁的发生。这一算法源自1965年E.F.科德（Edsger Dijkstra）提出的一个类比，它将操作系统中的进程与银行的...
操作系统银行家算法避免死锁
06-17
银行家算法避免死锁 VM软件 Linux系统 C语言 成功编译 成功运行 内附完整课设报告，代码，运行cpp 附有哲学家进餐简略一题 原课设要求：死锁避免 （1）请设计一个程序演示死锁避免算法（银行家算法）。 （2）要求该...
java实现银行家算法
08-25
Java 实现银行家算法详解 Java 实现银行家算法是操作系统中的一种资源分配算法，用于避免死锁和饥饿的出现。银行家算法的主要思想是，系统中存在一种有限的资源，多个进程竞争这些资源，需要避免死锁和饥饿的出现...
银行家算法模拟实验
04-21
银行家算法是从当前状态出发，逐个按安全序列检查各客户中谁能完成其工作，然后假定其完成工作且归还全部贷款，再进而检查下一个能完成工作的客户。如果所有客户都能完成工作，则找到一个安全序列，银行家才是安全的...
银行家算法python实现
03-26
保证能跑
java实现简单银行家算法
08-25
Java 实现简单银行家算法 一、标题解释 本文主要介绍了 Java 实现简单银行家算法的相关知识点，通过实例代码，详细介绍了银行家算法的实现过程。 二、描述解释 银行家算法是一种避免死锁的方法，它可以判断是否...
操作系统银行家算法
06-10
简单模拟银行家算法，实现了银行家算法的模拟，具有小规模学习的作用
银行家算法C语言代码.doc
05-18
银行家算法C语言代码 银行家算法是操作系统中的一种资源分配算法，用于避免死锁的产生。该算法通过跟踪每个进程的资源需求和当前可用的资源量来避免死锁的产生。 在本文档中，我们提供了银行家算法的C语言代码实现...
银行家算法----安全性检查C语言实现
qq_44761488的博客
12-15 1112
# include<bits/stdc++.h> using namespace std; # define maxn 105 int num_pr,num_re; struct Banker{ char name[10]; int max[maxn]; int allocation[maxn]; int need[maxn]; }a[maxn]; int resources[maxn]; int available[maxn]; int work[maxn];.
操作系统——银行家算法
qq_41648012的博客
05-28 695
银行家算法中数据结构主要是几个数组 1、可利用资源向量Available。这是一个含有m个元素的数组，其中的每一个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态地改变。如果Available[j]=K，则表示系统中现有Rj类资源K个。 2、最大需求矩阵Max。这是一个n×m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大...
操作系统——银行家算法实现
weixin_38312031的博客
11-04 375
操作系统——银行家算法实现 #include &lt;iostream&gt; using namespace std; int N; //进程个数 int M; //资源类型种类 int *C; //系统最大可用资源向量 int *Avail; //可用资源向量 int **MaxC; //最大需求矩阵 int **Alloc; //已分配资源矩阵 int **Need; //需求矩...
操作系统实验 银行家算法C++
m0_63476502的博客
11-23 3188
本文章是在原作者的银行家算法文章基础上依据实验课要求修改和完善的，仅供参考，侵权删。编程实现安全性算法及银行家算法，以帮助深刻理解银行家算法避免死锁的原理。
pycham银行家算法
最新发布
05-23
PyCharm 是一款 Python 集成开发环境（IDE），它内置了 Python 的调试器和运行环境，可以帮助开发者更加高效地编写 Python 代码。 银行家算法（Banker's Algorithm）是一种避免死锁的算法，主要用于操作系统中的进程调度。它通过预先计算系统资源分配的安全性来决定是否分配资源，以避免死锁的发生。在 PyCharm 中，银行家算法可以用来解决多线程程序中的资源竞争问题。 具体来说，银行家算法会将系统中的资源分为若干类别，并为每个类别分配一个总量和一个当前可用量。当一个线程需要访问某个资源时，它必须向系统发出请求，并提供自己需要的资源数量。系统会先检查当前是否有足够的资源满足该线程的请求，如果有，则会分配资源给该线程；否则，该线程必须等待。 在多线程程序中，银行家算法可以帮助开发者更好地管理共享资源，避免资源竞争和死锁的发生。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值