操作系统 - 银行家算法

最新推荐文章于 2025-05-30 00:50:16 发布

原创最新推荐文章于 2025-05-30 00:50:16 发布 · 401 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c语言 #c++

操作系统专栏收录该内容

4 篇文章

订阅专栏

本文介绍了银行家算法在操作系统中的应用，用于避免死锁现象。算法模拟银行借贷过程，确保资源的合理分配。通过初始化、安全性检查和资源请求处理等步骤，演示了如何在系统中安全地分配资源，以防止进程循环等待导致的系统不安全性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

程序实现思路银行家算法顾名思义是来源于银行的借贷业务，一定数量的本金要应多个客户的借贷周转，为了防止银行加资金无法周转而倒闭，对每一笔贷款，必须考察其是否能限期归还。在操作系统中研究资源分配策略时也有类似问题，系统中有限的资源要供多个进程使用，必须保证得到的资源的进程能在有限的时间内归还资源，以供其他进程使用资源。如果资源分配不得到就会发生进程循环等待资源，则进程都无法继续执行下去的死锁现象。把一个进程需要和已占有资源的情况记录在进程控制中，假定进程控制块 PCB 其中“状态”有就绪态、等待态和完成态。当进程在处于等待态时，表示系统不能满足该进程当前的资源申请。“资源需求总量”表示进程在整个执行过程中总共要申请的资源量显然，，每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以避免死锁.

在这里插入图片描述

#include <cstdio>
#include <iostream>
using namespace std;

#define W 10
#define R 20
#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();

int main()
{
    printf("实验五 死锁避免银行家算法实验。\n\n");
    Init();
    Safe();
    Bank();
    getchar();
}

void Init() /*初始化算法*/
{
    printf("请输入进程的数目:");
    scanf("%d", &m);
    printf("请输入资源的种类:");
    scanf("%d", &n);
    printf("请输入每个进程最多所需的各资源数,按照%dx%d矩阵输入\n", m, n);
    for (int i = 0; i < m; ++i)
        for (int j = 0; j < n; ++j)
            scanf("%d", &MAX[i][j]);
    printf("请输入每个进程已分配的各资源数,按照%dx%d矩阵输入\n", m, n);
    for (int i = 0; i < m; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            scanf("%d", &ALLOCATION[i][j]);
            NEED[i][j] = MAX[i][j] - ALLOCATION[i][j];
            if (NEED[i][j] < 0)
            {
                printf("您输入的第%d个进程所拥有的资源数错误,请重新输入:\n", i + 1);
                i--;
                j = n;
                continue;
            }
        }
    }
    printf("请输入各个资源现有的数目:\n");
    for (int i = 0; i < n; ++i)
    {
        scanf("%d", &AVAILABLE[i]);
    }
}
void Bank() /*银行家算法*/
{
    int cid = -1;
    while (1)
    {
        char judge = ' ';
        printf("请输入要申请资源的进程号(注:第 1 个进程号为 0,依次类推)\n");
        scanf("%d", &cid);
        cout << "请输入进程所请求的各资源的数量" << endl;
        for (int i = 0; i < n; ++i)
        {
            scanf("%d", &REQUEST[cid][i]);
            if (REQUEST[cid][i] > NEED[cid][i])
            {
                printf("您输入的请求数超过进程的需求量!请重新输入!\n");
                --i;
                continue;
            }
            if (REQUEST[cid][i] > AVAILABLE[i])
            {
                printf("您输入的请求数超过系统拥有资源数!请重新输入!\n");
                --i;
                continue;
            }
        }
        for (int i = 0; i < n; ++i)
        {
            AVAILABLE[i] -= REQUEST[cid][i];
            ALLOCATION[cid][i] += REQUEST[cid][i];
            NEED[cid][i] -= REQUEST[cid][i];
        }
        if (Safe())
        {
            printf("同意分配请求!\n");
        }
        else
        {
            printf("您的请求被拒绝!\n");
            for (int i = 0; i < n; ++i)
            {
                AVAILABLE[i] += REQUEST[cid][i];
                ALLOCATION[cid][i] -= REQUEST[cid][i];
                NEED[cid][i] += REQUEST[cid][i];
            }
        }
        for (int i = 0; i < m; ++i)
            FINISH[i] = false;
        printf("您还想再次请求分配吗?是请按 y/Y,否请按其它键\n");
        while (judge == ' ' || judge == '\n')
        {
            judge = getchar();
        }
        if (judge == 'y' || judge == 'Y')
        {
            continue;
        }
        break;
    }
}
bool Safe() /*安全性算法*/
{
    int l, flag = 0;
    int Work[MAXRESOURCE]; /*工作数组*/
    for (int i = 0; i < n; ++i)
        Work[i] = AVAILABLE[i];
    for (int i = 0; i < m; ++i)
        FINISH[i] = false;
    for (int i = 0; i < m; ++i)
    {
        if (!FINISH[i])
        {
            for (int j = 0; j < n; ++j)
            {
                if (NEED[i][j] > Work[j])
                {
                    break;
                    flag = 1;
                }
            }
            if (!flag)
            {
                FINISH[i] = true;
                for (int j = 0; j < n; ++j)
                {
                    Work[j] += ALLOCATION[i][j];
                }
                p[l++] = i;
                i = -1;
            }
            else
            {
                continue;
            }
            if (l == m)
            {
                printf("系统是安全的\n");
                printf("安全序列:\n");
                for (int ii = 0; ii < m - 1; ++ii)
                    printf("%d-->", p[ii]);
                printf("%d\n", p[m - 1]);
                return true;
            }
        }
    }
    printf("系统是不安全的\n");
    return false;
}