操作系统 银行家算法 安全性检查

最新推荐文章于 2024-05-12 21:11:34 发布
最新推荐文章于 2024-05-12 21:11:34 发布
阅读量5.1k 收藏 28
点赞数 6
文章标签： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44776065/article/details/109922873
版权

文章目录

算法描述

银行家算法

设进程I提出请求Request[N]，则银行家算法按如下规则进行判断

  1. 如果Request[N]<= Need [I, N]，则转(2)；否则，出错
  2. 如果Request[N]<= Available，则转(3)；否则，出错
  3. 系统试探分配资源，修改相关数据：
  • Available = Available -Request
  • Allocation = Allocation +Request
  • Need= Need - Request
  1. 系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待
安全性检查
  1. 设置两个工作向量Work= Available；Finish[M]=False
  2. 从进程集合中找到一个满足下述条件的进程
    Finish[i]=False
    Need <=Work

如找到，执行(3)；否则，执行(4)

  1. 设进程获得资源，可顺利执行，直至完成，从而释放资源
    Work=Work+ Allocation
    Finish=True
    Go To 2
  2. 如所有的进程Finish[M]=true，则表示安全；否则系统不安全

数据结构

int const RESOURCE_NUM = 20; // 最大资源的数目
int const PCB_COUNT = 10;    // 进程的数目
// 输入的进程
int M; //总进程数
int N; //资源种类
// 文件输出
ofstream fout;

char Name[RESOURCE_NUM];                 // 资源的名字
int PCBName[PCB_COUNT];                  // 进程的名字
int All_Resource[RESOURCE_NUM];          // 各种资源的数目总和
int Max[PCB_COUNT][RESOURCE_NUM];        // M个进程对N类资源最大资源需求量
int Available[RESOURCE_NUM];             // 系统可用资源数
int Allocation[PCB_COUNT][RESOURCE_NUM]; // M个进程已经得到N类资源的资源量
int Need[PCB_COUNT][RESOURCE_NUM];       // M个进程还需要N类资源的资源量
int Request[RESOURCE_NUM];               // 请求资源个数
int Work[RESOURCE_NUM] = {0};            // 系统可提供的资源数量
int Finish[RESOURCE_NUM] = {0};          // 完成的标志
int Security[PCB_COUNT];                 // 完成序列

//=========函数声明================
void initData();              // 输入信息
void showData();              // 展示输入的数据
bool safeAlgo();              // 安全序列函数
void allocationTest(int i);   // 对第i个进程分配预分配资源
void reAllocationTest(int i); // 对第 i 个进程回收预分配的资源
bool requestAlgo();           // 第 i 个进程请求资源
  • 获取系统的时间作为输出文件的名字
string getFileName(string algoName)
{
    // 获取时间 time_t是一个64位的整型。记录的是从1970-01-01 00:00:00到现在经过的时间，精度只能到秒
    time_t now = time(NULL);
    tm *t = localtime(&now);

    // 将信息输出到字符串流
    stringstream ss; // 引入sstream头文件
    ss << algoName << "LogFile" << t->tm_year + 1900 << "." << t->tm_mon + 1 << "." << t->tm_mday << ".." << t->tm_hour << "." << t->tm_min << "." << t->tm_sec << ".txt";
    cout << "写入的文件为: " << ss.str() << endl;
    return ss.str();
}
  • 输入资源信息、Max矩阵、Allocation矩阵
void initData()
{
    // 输入系统资源的种类与名字 名字用char类型
    cout << "输入系统资源的种类： " << endl;
    fout << "输入系统资源的种类： " << endl;

    cin >> N; // 资源的种类
    fout << N << endl;

    for (int i = 0; i < N; ++i)
    {
        cout << "资源的名字: " << endl;
        fout << "资源的名字: " << endl;

        cin >> Name[i];
        fout << Name[i] << endl;

        cout << "输入资源 " << Name[i] << " 的总个数 : " << endl;
        fout << "输入资源 " << Name[i] << " 的总个数 : " << endl;

        cin >> Available[i];
        fout << Available[i] << endl;
    }

    cout << "输入系统进程的数目：" << endl;
    fout << "输入系统进程的数目：" << endl;

    cin >> M; // M 进程的数目
    fout << M << endl;

    // 循环输入最大需求矩阵
    cout << "输入进程的最大需求矩阵" << endl;
    fout << "输入进程的最大需求矩阵" << endl;

    // 循环标志
    bool flag;

    // 每次输入是初始化输入为false
    flag = false;
    for (int i = 0; i < M; ++i)
    {
        cout << "第 " << i + 1 << " 个进程的Max矩阵" << endl;
        fout << "第 " << i + 1 << " 个进程的Max矩阵" << endl;

        PCBName[i] = i + 1;
        do
        {
            flag = false;
            for (int j = 0; j < N; ++j)
            {
                cin >> Max[i][j];
                fout << Max[i][j] << " ";
                // 输入检测，如果输入不合法，即需求的数目大于可分配的数目，重新输入所有的资源数目
                if (Max[i][j] > Available[j])
                {
                    flag = true;
                }
            }
            fout << endl;
            if (flag){
                cout << "输入需求的最大资源数不合法！请重新输入" << endl;
                fout << "输入需求的最大资源数不合法！请重新输入" << endl;
                cout << "第 " << i + 1 << " 个进程的Max矩阵" << endl;
                fout << "第 " << i + 1 << " 个进程的Max矩阵" << endl;
            }
            
        } while (flag);

    }

    // 初始化数据
    flag = false;
    /**
    * 输入分配的资源， 需要的资源为Need[i][j] = Max[i][j] - Allocation[i][j] 
    */
    for (int i = 0; i < M; ++i)
    {
        cout << "第 " << i + 1 << " 个进程的Allocation矩阵" << endl;
        fout << "第 " << i + 1 << " 个进程的Allocation矩阵" << endl;

        do
        {
            flag = false;
            for (int j = 0; j < N; ++j)
            {
                cin >> Allocation[i][j];
                fout << Allocation[i][j] << " ";

                if (Allocation[i][j] > Max[i][j])
                {   
                    flag = true;
                } else {
                    // 修改Need数组，得到还需分配的资源
                    Need[i][j] = Max[i][j] - Allocation[i][j];
                    // 修改Available数组， 得到系统剩余的资源
                     Available[j] -= Allocation[i][j];
                }
                
            }
            fout << endl;
            if (flag)
            {
                cout << "输入的Allocation大于Max！请重新输入" << endl;
                fout << "输入的Allocation大于Max！请重新输入" << endl;
                cout << "第 " << i + 1 << " 个进程的Allocation矩阵" << endl;
                fout << "第 " << i + 1 << " 个进程的Allocation矩阵" << endl;
            }
        } while (flag);
    }
}
  • 展示输入的信息
void showData()
{
    cout << "==========================================" << endl
         << endl;
    fout << "==========================================" << endl
         << endl;

    cout << "系统可用资源的数目: Avaliable: " << endl;
    fout << "系统可用资源的数目: Avaliable: " << endl;

    for (int i = 0; i < N; ++i)
    {
        cout << "   " << Name[i];
        fout << "   " << Name[i];
    }
    cout << endl;
    fout << endl;

    for (int i = 0; i < N; ++i)
    {
        cout << "   " << Available[i];
        fout << "   " << Available[i];
    }
    cout << endl;
    fout << endl;

    cout << "各个进程得到资源的情况: " << endl
         << "PCBName      Max      Allocation      Need" << endl;
    fout << "各个进程得到资源的情况: " << endl
         << "PCBName      Max      Allocation      Need" << endl;
    cout << "            ";
    fout << "            ";

    for (int i = 0; i < 3; ++i)
    {
        for (int j = 0; j < N; ++j)
        {
            cout << Name[j] << " ";
            fout << Name[j] << " ";
        }
        cout << "       ";
        fout << "       ";
    }
    cout << endl;
    fout << endl;

    for (int i = 0; i < M; ++i)
    {
        cout << PCBName[i] << "           ";
        fout << PCBName[i] << "           ";

        // 输出max
        for (int j = 0; j < N; ++j)
        {
            cout << Max[i][j] << " ";
            fout << Max[i][j] << " ";
        }
        cout << "       ";
        fout << "       ";

        // 输出Allocation
        for (int j = 0; j < N; ++j)
        {
            cout << Allocation[i][j] << " ";
            fout << Allocation[i][j] << " ";
        }
        cout << "       ";
        fout << "       ";

        // 输出Need
        for (int j = 0; j < N; ++j)
        {
            cout << Need[i][j] << " ";
            fout << Need[i][j] << " ";
        }
        cout << endl;
        fout << endl;
    }
}

安全性算法

bool safeAlgo()
{
    /**
     * @brief 
     * 安全性算法执行
     * 首先work赋值为Available, Finish全部赋值为false
     * 假设全部都分配给Need, 分配之后进行检测
     * 1. 每一次检测都从第一个开始，如果每一个Need可以被分配，则进行分配
     * 2. 分配完成之后，从第一个循环开始
     */
    // 初始化 work
    int securityCNT = 0;
    for (int i = 0; i < N; ++i)
    {
        Work[i] = Available[i];
    }
    // 初始化Finish
    for (int i = 0; i < M; ++i)
    {
        Finish[i] = false; // 开始的时候假设都没有完成
    }
    // 安全序列算法
    int resource = 0;
    for (int i = 0; i < M; i++)
    {
        // 每一次检测都初始化为0
        resource = 0;
        // 对资源分配进行检测
        for (int j = 0; j < N; ++j)
        {
            // 如果进程没有完成， 并且可以得到需要
            if (Finish[i] == false && Need[i][j] <= Work[j])
            {
                resource++;

                // 各种资源都可以得到满足的时候
                if (resource == N)
                {

                    // work资源改变
                    for (int k = 0; k < N; ++k)
                    {
                        // 占用资源释放，相当于 work[k] += Need[i][k] + Allocation[i][k]; Need未进行计算
                        Work[k] += Allocation[i][k];
                    }
                    // 完成标志
                    Finish[i] = true;
                    // 添加到完成序列
                    Security[securityCNT++] = PCBName[i]; // 进程号

                    i = -1; // ++i 后从0开始
                }
            }
        }
    }

    // 检测全部的Finish 如果有一个未false 则为不安全序列
    for (int i = 0; i < M; ++i)
    {
        if (Finish[i] == false)
        {
            cout << "系统处于不安全序列" << endl;
            fout << "系统处于不安全序列" << endl;
            return false;
        }
    }

    // 此时存在安全序列
    cout << "此时系统是安全的: ";
    fout << "此时系统是安全的: ";

    for (int i = 0; i < M; ++i)
    {
        if (i == M - 1)
        {
            cout << Security[i] << endl;
            fout << Security[i] << endl;
        }
        else
        {
            cout << Security[i] << " -> ";
            fout << Security[i] << " -> ";
        }
    }
    return true;
}

银行家算法


// 预分配
void allocationTest(int i)
{
    /**
     * @brief 
     * Available减少
     * allocation增加
     * Need改变
     */
    for (int j = 0; j < N; ++j)
    {
        Available[j] -= Request[j];
        Allocation[i][j] += Request[j]; // 占用资源增加
        Need[i][j] -= Request[j];       // 需要的资源减少
    }
}

// 预分配失败，返回
void reAllocationTest(int i)
{
    for (int j = 0; j < N; ++j)
    {
        Available[j] += Request[j];
        Allocation[i][j] -= Request[j];
        Need[i][j] += Request[j];
    }
}

bool requestAlgo()
{
    cout << "输入要分配资源的进程：  " << endl;
    fout << "输入要分配资源的进程：  " << endl;

    int P;
    cin >> P;
    fout << P << endl;
    P -= 1; // 转换为下标
    cout << "输入要分配各个资源的数目" << endl;
    fout << "输入要分配各个资源的数目" << endl;

    for (int i = 0; i < N; ++i)
    {
        cout << Name[i] << ": ";
        fout << Name[i] << ": ";

        cin >> Request[i];
        fout << Request[i];
    }

    // 对输入的资源进行检测
    for (int i = 0; i < N; ++i)
    {
        // 检测是否大于还需要的进程
        if (Request[i] > Need[P][i])
        {
            cout << "资源申请大于 Need" << endl;
            fout << "资源申请大于 Need" << endl;

            return false;
        }
        else
        {
            // 检测是否有可用的资源
            if (Request[i] > Available[i])
            {
                cout << "申请资源大于 Avaliable" << endl;
                fout << "申请资源大于 Avaliable" << endl;

                return false;
            }
        }
    }

    // 合法 检测通过
    allocationTest(P); // 预分配资源
    showData();
    if (!safeAlgo())
    {
        // 没有安全序列
        reAllocationTest(P);
        showData();
        return false;
    }
    else
    {
        reAllocationTest(P);
        showData();
        return true;
    }
}

主函数

int main()
{
	// 得到文件名
    string fileName = getFileName("BankAlgo");
    // 打开文件
    fout.open(fileName.c_str());
    initData();
    showData();
    if (!safeAlgo())
    {
        return -1;
    }
    while (1)
    {
        requestAlgo();
        cout << "\t\tCtrl + C 结束进程" << endl
             << endl;
    }
    return 0;
}

测试用例

3
A
10
B
5
C
7

5
7 5 3
3 2 2
9 0 2
2 2 2
4 3 3

0 1 0
3 0 2
3 0 2
2 1 1
0 0 2
LiQiang33
关注
操作系统银行家算法.doc
11-13
操作系统银行家算法 操作系统银行家算法是一种资源分配算法，用于解决操作系统中的资源竞争问题。该算法通过检查系统的安全性和稳定性，确保系统不会陷入死锁或饥饿状态。 银行家算法的原理 银行家算法的核心思想...
7-1 银行家算法--安全性检查 (20 分)(思路+详解+知识分析)宝 你今天 AC了吗
qq_48508278的博客
10-31 7310
一：前言 停更一周了，在这一周里，我每时每刻都在 想这我这 29个粉丝，庆幸教师资格证终于结束了，贴心杰又可以天天更新博客了 哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈，I am come back; 二：题目： 输入N个进程(N<=100)，以及M类资源（M<=100），初始化各种资源的总数，T0时刻资源的分配情况。判断T0时刻是否安全。例如： 假定系统中有5个进程{P0，P1，P2，P3，P4}和三类资源{A,B,C}，各种资源的数量分别为10、5、7，在T0时刻的资源分配图如下： 输入格式:
JAVA面试：多线程
AmamiyaNen的博客
07-06 173
并发（Concurrent）和并行（Paraller） 并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。两个队列和一台咖啡机。 并行：多个处理器或多核处理器同时处理多个任务。 两个队列和两台咖啡机。 线程和进程的区别 进程是操作系统资源分配的基本单位。 线程是 的基本单位。 资源开销：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行
计算机操作系统——银行家算法
青柠晶晶的博客
05-24 7591
1.实验目的： 银行家算法是由Dijkstra设计的最具有代表性的避免死锁的算法。本实验通过编写一个模拟动态资源分配的银行家算法程序，进一步深入理解死锁、产生死锁的必要条件、安全状态等重要概念，并掌握避免死锁的具体实施方法。 2.实验内容：        （1）模拟一个银行家算法：   设置数据结构   设计安全性算法 （2）初始化时让系统拥有一定的资源； （3）用键盘
银行家算法:安全性检测及资源申请分配（c）
Feixiangdechenyu的博客
06-01 315
多个进程同时运行时，系统根据各类系统资源的最大需求和各类系统的剩余资源为进程安排安全序列，使得系统能快速且安全地运行进程，不至发生死锁。银行家算法是避免死锁的主要方法，其思路在很多方面都非常值得我们来学习借鉴。
操作系统实验二死锁避免之银行家算法的模拟
人生处处是围城，一切都是最好的安排！
10-31 7370
操作系统实验，使用银行家算法来进行死锁避免，用C++模拟银行家算法的过程，理解银行家算法、死锁产生的条件、安全性检查算法、安全状态与安全序列
操作系统实验二——银行家算法
08-29
4. 安全性检查：如果安全，资源分配成功；否则，撤销分配，进程等待。 在给出的源程序中，定义了数组来存储各个进程的资源需求、已分配资源、最大需求以及系统可用资源。`hasCheck()`函数实现了安全判定算法，通过...
计算机操作系统-银行家算法
05-22
《计算机操作系统——深入理解银行家算法》 操作系统作为计算机系统的核心，负责管理和调度系统的资源，以确保多个进程公平且高效地执行。其中，银行家算法是解决死锁预防问题的一种经典策略，它由E.F.科恩在1965年...
操作系统银行家算法，C语言
03-31
操作系统中的银行家算法是一种资源分配和调度策略，用于预防死锁的发生。它是1965年由E.F.科德提出的一种安全算法，主要用于确保系统在分配资源时不会进入无法解除的死锁状态。该算法假设系统有一个中央调度者，它...
银行家算法+安全性检查 【 死锁 】
weixin_74118029的博客
05-10 2081
printf("进程P%d Request_%c=%d > Available_%c=%d \n",i,'A'+j,Request[j],'A'+j,banker.Available[j]);综上所述，银行家算法的具体思想是通过动态地分析系统中各进程的资源需求，预测资源分配后系统是否会处于安全状态，以此来避免系统陷入死锁的危险状态，保证系统的稳定性和可靠性。// 输出请求向量中的资源数量。(2) 如果 Requesti[j]≤Available[j]，便转向步骤(3):否则，表示尚无足够资源，P须等待。
银行家算法及安全性检验实验
m0_53602804的博客
11-30 977
银行家算法实验
操作系统-银行家算法上机实验
cangzhexingxing的博客
05-19 3982
操作系统原理实验报告 实验题目 实验三银行家算法 实验三、银行家算法 1.1 实验目的 多个进程动态地共享系统的资源可能会产生死锁现象。死锁的产生，必须同时满足四个条件，第一个是互斥条件，即一个资源每次只能由一个进程占用；第二个为请求和保持条件，即一个进程请求资源不能满足时，它必须等待，但它仍继续保持已得到的所有其它资源；第三个是不剥夺条件，任何一个进程不能抢占另一个进程已经获得且未释放的资源；第四个为循环等待条件，系统中存在若干个循环等待的进程，即其中每一个进程分别等待它前一...
网络安全就业前景好不好？0基础可以学吗？_入门级网络安全工程师好就业吗
2401_84301948的博客
04-27 342
对于从来没有接触过网络安全的同学，我们帮你准备了详细的。可以说是，大家跟着这个大的方向学习准没问题。
7-1 银行家算法--安全性检查 (20 分)(思路+详解+知识分析)宝 你今天 AC了吗(1)
最新发布
2301_82242964的博客
05-12 434
在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。需要完整版PDF学习资源私我。
银行家算法01--安全性检查 (操作系统)
asdbkaj的博客
12-04 5768
银行家算法01–安全性检查 (操作系统) 输入N个进程(N<=100)，以及M类资源（M<=100），初始化各种资源的总数，T0时刻资源的分配情况。判断T0时刻是否安全。例如： 假定系统中有5个进程{P0，P1，P2，P3，P4}和三类资源{A,B,C}，各种资源的数量分别为10、5、7，在T0时刻的资源分配图如下： 输入格式: 第一行输入进程数量N，第二行输入资源类数M，第三行输入M类资源个类资源的总数，以下N行分别输入每个进程的名字，该进程对M类资源的最大需求以及已分配资源。 输出格式:
操作系统实训（银行家算法）
qq_43379059的博客
07-22 1026
操作系统实训（银行家算法）
c++通过银行家算法检查安全性，并输出安全序列
m0_67532085的博客
04-26 732
用通俗易懂的语言写出c++通过银行家算法检查安全性，并输出安全序列
银行家算法判断状态是否安全
热门推荐
mez_Blog的博客
06-20 1万+
process allocation need avaiable p0 0 0 3 2 0 0 1 2 1 6 2 2 p1 1 0 0 0 1 7 5 0 p2 1 3 5 4 2 3 5 6 p3 0 3 3 2 0 6 5 2 p4 0 0 1 4 0 6 5 6 资源 进程 ...
操作系统实验：银行家算法详解与安全性检查
"这篇实验报告详细介绍了银行家算法及其在操作系统中的应用，旨在帮助读者理解银行家算法的工作原理，掌握进程安全性检查与资源分配的方法，同时深入理解死锁的避免策略。报告中还包含了对实验设计的思路以及安全...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值