【附源码】银行家算法（C语言）

已于 2024-09-11 20:37:35 修改
阅读量322 收藏 6
点赞数 4
文章标签： 算法 c语言
于 2024-08-31 12:37:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60308062/article/details/141750927
版权

银行家算法是一种用于避免死锁的算法，特别适用于资源分配问题。在多道程序设计中，多个进程需要共享有限的资源，如内存、CPU时间片、I/O设备等。银行家算法通过在分配资源时进行安全性检查，确保系统不会进入死锁状态。

一、银行家算法的基本概念

  1. 进程（Process）： 请求资源的主体。
  2. 资源类型（Resource Types）： 各类资源，如CPU、内存等。
  3. 最大需求矩阵（Max）： 每个进程对每种资源的最大需求。
  4. 已分配矩阵（Allocation）： 当前已经分配给每个进程的资源。
  5. 需求矩阵（Need） 每个进程还需要的资源，Need[i][j] = Max[i][j] - Allocation[i][j]。
  6. 可用资源向量（Available）： 当前可供分配的资源总量。
  7. 工作向量（Work）： 当前可用的资源，在算法执行中用来模拟资源分配过程。
  8. 完成向量（Finish）： 标记进程是否完成，初始值为 false。

二、代码

运行效果

完整代码

#include <malloc.h>
 
#include <stdio.h>
 
#include <string.h>
 
#include <windows.h>
 
#define M 3 //资源种类
 
#define N 5 //作业数量
 
#define False 0
 
#define True 1
 
 
char name[N];//资源的名称
 
int Request[N]={0}; //进程的请求资源向量
 
int Resource[M];//各资源总数
 
int Max[N][M];//各进程对各类资源的最大需求
 
int Allocation[N][M];//各进程已分配资源
 
int Need[N][M];//各进程还需要资源
 
int Available[M];//系统可用资源向量
 
int Work[M];//存放系统可提供使用资源，工作向量
 
int Finish[N];//判断安全性标志
 
int temp[N];//存放安全序列的下标序列 list
 
 
void initial()   
 
//创建初始状态：先输入 Resource、Max和 Allocation，再计算出 Need、Available。   
 
{
 
    int i,j;
 
    printf("请输入3种资源的总数量:\n");
 
    for(i=0;i<M;i++)
 
    {
 
        scanf("%d",&Resource[i]);
 
        Available[i]=Resource[i];  // 此时，可利用资源数=总资源数
 
    }
 
    printf("请输入5个进程分别对M种资源的最大需求量:\n");
 
    for(j=0;j<N;j++)
 
        for(i=0;i<M;i++)
 
            scanf("%d",&Max[j][i]); // 最大需求量
 
    printf("请输入N个进程获得M种资源的数量:\n");
 
    for(j=0;j<N;j++)
 
        for(i=0;i<M;i++)
 
            scanf("%d",&Allocation[j][i]);   // 已分配各资源数
 
 
    for(j=0;j<N;j++)
 
        for(i=0;i<M;i++)
 
            Need[j][i]=Max[j][i]-Allocation[j][i];  // 还需资源数
 
    for(j=0;j<M;j++)
 
        for(i=0;i<N;i++)
 
            Available[j]=Available[j]-Allocation[i][j]; // 还可利用资源数
 
}

 
void printState()   
 
//输出当前的状态表
 
{
 
    int i;
 
printf("状态表:\n|Process     |Max         |Allocation  |Need        |Available   | \n");
 
printf("\t     |   %c   %c   %c|   %c   %c   %c|   %c   %c   %c|   %c   %c   %c| \n",name[0],name[1],name[2],name[0],name[1],name[2],name[0],name[1],name[2],name[0],name[1],name[2]);
 
    for(i=0;i<N;i++)
 
    {
 
        if(i==0)
 
            printf("|P%-11d|%4d%4d%4d|%4d%4d%4d|%4d%4d%4d|%4d%4d%4d|\n",i,Max[i][0],Max[i][1],Max[i][2],Allocation[i][0],Allocation[i][1],Allocation[i][2],Need[i][0],Need[i][1],Need[i][2],Available[0],Available[1],Available[2]);  // 输出11位整型数, 不够11位按左对齐
 
        else
 
            printf("|P%-11d|%4d%4d%4d|%4d%4d%4d|%4d%4d%4d|            |\n",i,Max[i][0],Max[i][1],Max[i][2],Allocation[i][0],Allocation[i][1],Allocation[i][2],Need[i][0],Need[i][1],Need[i][2]);
 
    }
 
}
 

 
int isfinish()   
//返回同时满足两个条件{①Finish[i]=false;  ②Need[i][j]≤Work[j]}的进程下标 i(修改Finish[i]=true)，否则返回-1。 需求≤可利用
{
 
    int i,j,count;
 
    for(i=0;i<N;i++)   // 计算每个进程finish值
 
    {
 
        for(j=0,count=0;j<M;j++)   
 
            if(Finish[i]==0 && Need[i][j]<=Work[j])  // 仅暂时未分配成功的进程的资源进行判断并计数
 
            {
 
                count++;
 
            }
 
        if(count==3)   // 表示进程中三个资源均可被分配
 
        {
 
            for(j=0;j<M;j++)
 
                Work[j]+=Allocation[i][j];  // 分配
 
            Finish[i]=1;    // 进程可结束
 
            return i;      // 返回新分配资源的进程号
 
        }
 
    }
 
    return -1;
 
}
 
 
int issafe()   
 
//判定当前状态是否为安全状态 （返回 true 或 false），把安全序列的下标放入 List[N]数组。
 
{
 
    int i,a,count=0;
 
    for(i=0;i<M;i++)
 
        Work[i]=Available[i];  // 此时，各资源现可利用数=剩余可利用的各资源数
 
    for(i=0;i<N;i++)
 
        Finish[i]=0;   // 初始化finish[ ]数组，均设为false
 
    for(i=0;i<N;i++)
 
    {
 
        a=isfinish();
 
        if(a!=-1)     // 表示可结束的安全序列下标
 
        {
 
            temp[i]=a;
 
            count++;   // 记录可安全结束的进程数量
 
        }
 
    }
 
    if(count==5)
 
        return 1;      // 存在安全序列
 
    else
 
        return 0;      // 不存在安全序列
 
}
 
 
void printList( )   
 
//输出安全序列表|Process |Work  |Need   |Allocation  |Work+Alloc   |Finish  |
 
{
 
    int i,j;
 
printf("\n安全序列表如下:\n|Process     |Work        |Need        |Allocation  |Work+Alloc  |Finish      |\n");
 
printf("\t     |   %c   %c   %c|   %c   %c   %c|   %c   %c   %c|   %c   %c   %c|\n",name[0],name[1],name[2],name[0],name[1],name[2],name[0],name[1],name[2],name[0],name[1],name[2]);
 
for(j=0;j<M;j++)
 
    {
 
        Work[j]=Available[j];
 
    }
 
    for(i=0;i<N;i++)
 
    {
 
        printf("|P%-11d|%4d%4d%4d|%4d%4d%4d|%4d%4d%4d|%4d%4d%4d|true\n",temp[i],Work[0],Work[1],Work[2],Need[temp[i]][0],Need[temp[i]][1],Need[temp[i]][2],Allocation[temp[i]][0],Allocation[temp[i]][1],Allocation[temp[i]][2],Work[0]+Allocation[temp[i]][0],Work[1]+Allocation[temp[i]][1],Work[2]+Allocation[temp[i]][2]);
 
        for(j=0;j<M;j++)
 
            Work[j]+=Allocation[temp[i]][j]; 
 
    }
 
}
 

void reqresource(int i, int Request[M])   
 
//表示第 i个进程请求 M类资源 request[M]
 
{
 
    int flag,count1,count2;
    int j;
    //Step1:  判断条件 Request[j]≤Need[i][j]
    for(j=0,count1=0;j<M;j++)
        if(Request[j]<=Need[i][j])
            count1++;
    //Step2:  判断条件 Request[j]≤Available[j]
    for(j=0,count2=0;j<M;j++)
        if(Request[j]<=Available[j])
            count2++;
    if(count2!=3)
        printf("\n尚无足够的资源，第%d个进程堵塞。\n",i);  // 越界
    //Step3:  预先分配
    if(count2==3 && count1==3)  // 未越界
    {
        for(j=0;j<M;j++)
        {
            Available[j]=Available[j]-Request[j];
 
            Allocation[i][j]=Allocation[i][j]+Request[j];
 
            Need[i][j]=Need[i][j]-Request[j];
 
        }    // 预先更新进程i的Available，Allocation，Need状态表
 
        if(issafe()==0)
 
        {
            printf("\n不存在安全序列，不是安全状态。\n");
            for(j=0;j<M;j++)
            {
 
                Available[j]=Available[j]+Request[j];
 
                Allocation[i][j]=Allocation[i][j]-Request[j];
 
                Need[i][j]=Need[i][j]+Request[j];
 
            }   // 恢复进程i的Available，Allocation，Need状态表
        }
        else
        {
            printf("\n是安全序列分配成功!\n");
 
            printList();
        }   
    }
    //Step4:检测是否为安全状态
}
 
int main()
 
{   
 
    int reqid=-1,j;
 
    initial(); // 初始化
 
for(int a=0;a<M;a++){
 
    name[a]=a+65;
 
} // 定义资源名称A,B,C
 
printState();  // 输出状态表
 
    if(issafe()==0)  // 判断安全状态
 
    {
 
        printf("初始状态不安全！\n");
 
    }
 
    else
 
    {
 
        printf("\n初始状态是安全的！\n");
 
        printList(); // 输出安全序列状态表 
 printf("\n"); 
        printf("请输入请求资源进程号（如 1，2，3）:");
 
        scanf("%d",&reqid);  // 输入请求资源id号
 
        while(reqid>=0 && reqid<N)   // 判断输入进程 id是否合法 
 
        {
 
            printf("请输入请求资源:");  
 
            for(j=0;j<M;j++)
 
            {
 
                scanf("%d",&Request[j]);
 
            }    // 输入请求资源进程的各资源请求数
 
            reqresource(reqid, Request);  // 进程reqid请求Request[M]资源
 
            printState();
 printf("\n"); 
            printf("请输入请求资源进程号（如 1，2，3）:");
 
            scanf("%d",&reqid); 
 
        } 
 
} 
 
return 0;
 
}

～－～
关注
银行家算法C语言版.txt
05-19
银行家算法C语言版.txt
银行家算法课程设计（附源代码）
振华OPPO的博客世界
03-26 1万+
死锁会引起计算机工作僵死，因此操作系统中必须防止。本实验提供了一个系统动态分配资源的简单模拟程序，用于了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生。 Request i 是进程Pi 的请求向量。Request i（j）=k表示进程Pi请求分配Rj类资源k个。当Pi发出资源请求后，系统按下述步骤进行检查： 1．如果Request i≤Need，则转向步骤2；否则，认为出错，因为它所请求的资源数已超过它当前的最大需求量。 2．如果Request i≤Available，则转向步骤3；否则，表示
操作系统死锁避免——银行家算法
haohulala的博客
06-14 710
银行家算法主要分为两个部分，第一部分是银行家进行资源分配可行性检查；第二部分是安全性算法对模拟分配后是否有一个不会产生进程死锁的安全序列进行检查。银行家算法的主要数据结构如下：#include &lt;iostream&gt; using namespace std; const int max_resource = 10; //最大的资源种类 const int max_progress ...
操作系统页面置换算法之最佳(OPT)置换算法（C语言实现）
CuriosityCAX的博客
12-09 9665
最佳(OPT)置换算法 #include <iostream> int accessPage[20] = { 7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1 }; int flagOPT[3] = { -1,-1,-1 }; // 用来在OPT算法中标记三个物理块是否有页面；-1：物理块中没有页面；1：物理块中有页面；0：物理块中的页面会在随后的页面访问中被访问 int physicalBlock[3] = { -1,-1,-1 }; // 3个物
操作系统避免死锁——银行家算法实现
博客小站
12-25 1488
银行家算法是针对操作系统资源分配中可能导致的死锁问题，主要是通过对资源请求满足之后的状态检测，如果满足请求之后系统状态安全，则说明不会产生死锁，可以满足申请；如果满足之后的状态不安全，则有可能会形成死锁，故而不能满足请求。从而达到避免死锁的发生。 死锁检测需要使用安全性算法，该算法只用于对当前状态是否为死锁进行检测，这里用于在银行家算法中对于满足请求之后的系统状态进行检测。其中，死锁的检测方法还...
轻松掌握银行家算法-避免死锁
qq_45602697的博客
05-13 361
1.设置四种数据结构，resourcenum定义为资源的类别，processnum为进程号，可利用资源向量数组available，最大需求矩阵Max。已经分配好资源的矩阵allocation，需求矩阵need。以及定义了一些程序所必须的变量，基础准备 2…对于安全的算法，该程序主要是通过不断的循环遍历来找到一个可以合理分配资源的安全序列，如果不存在就直接指出该系统是不安全的 下面是具体代码实现 #include <stdio.h> #define resourcenum 3 #define pr
银行家算法C语言实现 源码及可执行文件 LINUX.zip
07-12
在提供的压缩包“银行家算法C语言实现 源码及可执行文件 LINUX”中，包含了源代码和编译好的可执行文件，这可能是为了方便用户在Linux环境中理解和学习银行家算法。通过阅读源码，我们可以看到如何将上述理论应用于...
银行家算法-有源码.docx
06-05
《银行家算法详解及C语言实现》 银行家算法是一种著名的资源分配策略，由艾兹格·迪杰斯特拉在1965年提出，旨在避免操作系统的死锁问题。这个算法模拟了银行家如何安全地分配贷款，以确保所有借款人最终都能偿还...
操作系统 银行家算法模拟实验（报告中附源码）
05-12
源程序代码示例展示了如何用C语言实现银行家算法，包括工作节点结构体、资源分配和需求的数组，以及处理进程资源分配的函数，如添加资源、判断资源是否足够、输出安全序列等。bankalgo()函数是银行家算法的核心，...
银行家算法C源码
03-08
总的来说，理解银行家算法C源码不仅需要掌握C语言基础，还需要对操作系统原理，尤其是资源管理和并发控制有深入的理解。通过对源码的分析和调试，我们可以更好地掌握银行家算法的工作机制，并将其应用于实际的系统...
操作系统：避免死锁的银行家算法及安全性算法/C++
qq_64960904的博客
12-30 2053
利用C++实现避免死锁中的银行家算法以及安全性算法，实现某进程每次请求资源是否安全的判断。
操作系统实验之预防进程死锁的银行家算法
qq_41696136的博客
01-14 1294
一、实验内容 设计程序模拟预防进程死锁的银行家算法的工作过程。假设系统中有n个进程P1, … ,Pn，有m类可分配的资源R1, … ,Rm，在T0时刻，进程Pi分配到的j类资源为Allocationij个，它还需要j类资源Need ij个，系统目前剩余j类资源Workj个，现采用银行家算法进行进程资源分配预防死锁的发生。 二、C++代码 写的太冗长辽 #include<iostream&gt...
银行家算法C++实现
热门推荐
lingpy的博客
04-12 3万+
网上有很多银行家算法的源代码，下面是本人自己写的，基本算法模型参考教材。 介绍 银行家算法（Banker’s Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉（Edsger Wybe Dijkstra）在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。 背景简介 在银行中...
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1132
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
排序算法之归并排序
qq_64039411的博客
10-01 517
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
算法：按既定顺序创建目标数组
AWSDN的博客
09-29 246
本文主要介绍按既定顺序创建目标数组问题
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1310
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
【韩顺平Java笔记】第6章：数组、排序和查找
最新发布
随手写写
10-02 718
排序是将多个数据，依指定的顺序进行排列的过程。
C语言实现的银行家算法详解与源码展示
"银行家算法是一种用于预防死锁的策略，通过C语言实现。它涉及四个关键数据结构：Available数组记录当前可用资源，Max矩阵存储每个进程的最大需求，Allocation矩阵表示已分配的资源，Need矩阵表示进程还需要的资源。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值