银行家算法的 Python 代码实现 - 操作系统

最新推荐文章于 2023-12-29 03:00:00 发布
最新推荐文章于 2023-12-29 03:00:00 发布
阅读量6.7k 收藏 140
点赞数 14
分类专栏： Python 文章标签： 操作系统 python 算法 银行家算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jaykm/article/details/106379447
版权

封面

😋 发布且更更新于个人小破站：进去瞅瞅

银行家算法介绍

之所以叫做银行家算法是因为该算法原本是为银行系统设计的，以确保银行在发放现金贷款的时候，不会发生不能满足所有客户要求的情况。在 OS 中也可以用来避免死锁。

为了实现银行家算法，每一个进程在进入系统时，它必须申明在运行过程中可能需要煤种资源类型的最大单元数目，其数目不能超过系统所拥有的资源总量。当进程请求一组资源的时候，系统必须首先确定是否有足够的资源分配给该进程。若有，再进一步计算，在将这些资源分配给进程之后，是否会使系统处于不安全状态，如果不会，才将资源分配给他，否则让进程等待。

为了实现银行家算法，在系统中必须要设置这样四个数据结构，分别用来描述系统中可利用的资源、所有进程对资源的最大需求、系统中的资源分配，以及所有进程还需要多少资源的情况。

  1. 可利用资源向量 Available ，它是一个含有 m 个元素的数组，其中的每一个元素代表一类可利用的资源的数目，其初始值是系统中所配置的该类全部可用资源数目。其数值随该类资源的分配和回收而动态地改变。如果Available[j]=k，表是系统中现有 Rj 类资源 k 个。

  2. 最大需求矩阵 Max，这是一个 n×m 的矩阵，它定义了系统中 n 个进程中的每一个进程对 m 类资源的最大需求。如果Max[i,j]=k，表示进程 i 需要 Rj 类资源的最大数目为 k 。

  3. 分配矩阵 Allocation ，这是一个 n×m 的矩阵，它定义了系统中的每类资源当前一分配到每一个进程的资源数。如果Allocation[i,j]=k，表示进程 i 当前已经分到 Rj 类资源的数目为 k。Allocation[i] 表示进程 i 的分配向量，有矩阵 Allocation 的第 i 行构成。

  4. 需求矩阵 Need ，这是一个n×m的矩阵，用以表示每个进程还需要的各类资源的数目。如果Need[i,j]=k，表示进程 i 还需要 Rj 类资源 k 个，才能完成其任务。Need[i] 表示进程 i 的需求向量，由矩阵 Need 的第 i 行构成。

上述三个矩阵间存在关系：Need[i,j]=Max[i,j]-Allocation[i,j];

银行家算法

设 Request 是进程Pi的请求向量，如果 Requesti[j] = K，表示进程 Pi 需要 K 个 Rj 类型的资源。当 Pi 发出资源请求后，系统按下述步骤进行检査:

  1. 如果 Requesti[j] ≤ Need[i,j]便转向步骤 2；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。

  2. 如果 Requesti[j] ≤ Available[j]，便转向步骤 3；否则，表示尚无足够资源，Pi须等待。

  3. 系统试探着把资源分配给进程 Pi，并修改下面数据结构中的数值

    Available[j] = Available[j] - Requesti[j]; // 分配出去
Allocation[i,j] = Allocation[i,j] + Requesti[j]; // 获得资源
Need[i,j] = Need[i,j] - Requesti[j];　　　　// 需求减少

  4. 系统执行安全性算法，检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程 Pi ，以完成本次分配；否则，将本次的试探分配作废，恢复原来的资源分配状态，让进程 Pi 等待。

安全性算法

系统所执行的安全性算法可描述如下:

  1. 设置两个向量：① 工作向量 Work ，它表示系统可提供给进程继续运行所需的各类资源数目，它含有 m 个元素，在执行安全算法开始时，Work = Available；② Finish: 它表示系统是否有足够的资源分配给进程，使之运行完成。默认全部为 False。

  2. 从进程集合中找到一个能满足下述条件的进程

    • Finish[i] = False;

    • Need[i] ≤ Work; （向量比较）

    若找到，执行步骤 3，否则，执行步骤 4 ；

  3. 当进程 Pi 获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行:
    　　Work = Work + Allocation[i] （向量运算）
    　　Finish[i] = True;
    　　转到步骤 2

  4. 如果所有进程的 Finish[i] = True都满足，则表示系统处于安全状态；否则，系统处于不安全状态。

具体实现

相信上过这门的的同学都已经对这个算法有了一定的了解，那么按照书上面的步骤来写代码的话问题也不是很大，但是在实现的时候需要很多的细节，相信这篇文章会在你一筹莫展的提供一些思路。

数据结构的构建

通过前面的介绍我们已经了解到，「银行家算法」至少要涉及到 4 个数据结构，所以第一步就是如何获取这四个数据结构；

def main():
    """主循环算法"""
    m = int(input("输入资源种类数 m: "))

    temp = input("输入进程数资源，空格隔开：").split()
    available = np.array(temp, dtype=int)

    n = int(input("输入进程数 n: "))
    max_table = np.zeros([n, m], dtype=int)
    allocation = np.zeros([n, m], dtype=int)
    
    # 输入最大需求资源
    for i in range(n):
        temp = input("输入进程 P{} 的最大需求向量 Max：".format(i)).split()
        max_table[i] = np.array(temp, dtype=int)

        if (available < max_table[i]).any():
            print("[ERROR] 输入有误，重新输入")
            i -= 1
    # 输入已分配资源
    for i in range(n):
        temp = input("输入进程 P{} 的已分配资源 Max：".format(i)).split()
        allocation[i] = np.array(temp, dtype=int)

        if (max_table[i] < allocation[i]).any():
            print("[ERROR] 输入有误，重新输入")
            i -= 1

    # 导入测试数据，不用一次次手动输入
    # available, max_table, allocation = loadTestData()
    need = max_table - allocation
    
    # 剩余部分代码暂时省略，后面会介绍

在测试的时候一次次测试比较麻烦，其实最方便的办法就是预先定义一份测试数据，然后使用 loadTestData() 来获取，下面的这一份数据是从书本上摘抄的，可以用来作为测试数据。

def loadTestData():
    return (np.array([10, 5, 7], dtype=int),
        np.array([[7, 5, 3],
                  [3, 2, 2],
                  [9, 0, 2],
                  [2, 2, 2],
                  [4, 3, 3]], dtype=int),
        np.array([[0, 1, 0],
                  [2, 0, 0],
                  [3, 0, 2],
                  [2, 1, 1],
                  [0, 0, 2]], dtype=int))

银行家算法

银行家算法实际上就是一个循环，循环获取资源请求，然后对资源请求进行判断，判断该请求的合法性以及安全性：

# main() 函数内部，接上
while (need != 0).any():
    proc_ind, req = input("输入请求，如：P1, 1 0 1: ").split(',')
    proc_ind = int(proc_ind[1:])
    req = np.array(req.split(), dtype=int)

    # 判断合法性
    if (req > max_table[proc_ind]).any():
        print("[ERROR] 输入有误，重新输入")

    # 判断安全性
    else:
        available -= req
        allocation[proc_ind] += req
        need[proc_ind] -= req
        # security 是安全性算法，下面会解释到
        if security(available.copy(), need, allocation):
            # printTable 是打印当前状态，具体实现可以看文末完整代码
            printTable(available, max_table, allocation, need)
            continue
        else:
            print("[ERROR] 不安全，不能分配")
            available += req
            allocation[proc_ind] -= req
            need[proc_ind] += req

安全性算法

上面的代码中 security(available.copy(), need, allocation) 是安全性算法，因为 avaiable 传到该函数之后会被当做 work 变量使用，会导致该数据被修改，所以这里采用的是 avaiable.copy()来复制一份；

def security(work, need, allocation):
    """安全性算法"""
    n = need.shape[0]
    finish = np.array([False] * n, dtype=bool)
    while not(finish.all()):
        flag = False
        for i in range(n):
            if not finish[i] and (need[i] <= work).all():
                print("P{}".format(i), end=' -> ')
                flag = True
                work += allocation[i]
                finish[i] = True
                break
        if not flag:
            return False
    print()
    return True

在安全性算法里面，是按照书上的流程写出来的，只不过在判断是否安全的时候，添加了一个 flag 变量，当一次完整的 for 循环结束之后，flag 为 False，也就是说没有找到满足条件的进程，就代表此时这个分配是不安全的，当所有的进程都为 True 之后才是安全的。

运行结果

运行结果

完整代码代码以及参考资料

import numpy as np

def security(work, need, allocation):
    """安全性算法"""
    n = need.shape[0]
    finish = np.array([False] * n, dtype=bool)
    while not(finish.all()):
        flag = False
        for i in range(n):
            if not finish[i] and (need[i] <= work).all():
                print("P{}".format(i), end=' -> ')
                flag = True
                work += allocation[i]
                finish[i] = True
                break
        if not flag:
            return False
    print()
    return True


def printTable(available, max_table, allocation, need):
    """输出表格"""
    print("=="*30)
    print("进程\tMax\tAllo\tNeed")
    for i in range(5):
        print("P{}\t{}\t{}\t{}".format(
            i, max_table[i], allocation[i], need[i]))
    print("当前剩余资源:", available)


def loadTestData():
    """导入测试数据"""
    return (np.array([10, 5, 7], dtype=int),
        np.array([[7, 5, 3],
                  [3, 2, 2],
                  [9, 0, 2],
                  [2, 2, 2],
                  [4, 3, 3]], dtype=int),
        np.array([[0, 1, 0],
                  [2, 0, 0],
                  [3, 0, 2],
                  [2, 1, 1],
                  [0, 0, 2]], dtype=int))


def main():
    """主循环算法"""
    m = int(input("输入资源种类数 m: "))

    temp = input("输入进程数资源，空格隔开：").split()
    available = np.array(temp, dtype=int)

    n = int(input("输入进程数 n: "))
    max_table = np.zeros([n, m], dtype=int)
    allocation = np.zeros([n, m], dtype=int)
    
    # 输入最大需求资源
    for i in range(n):
        temp = input("输入进程 P{} 的最大需求向量 Max：".format(i)).split()
        max_table[i] = np.array(temp, dtype=int)

        if (available < max_table[i]).any():
            print("[ERROR] 输入有误，重新输入")
            i -= 1
    # 输入已分配资源
    for i in range(n):
        temp = input("输入进程 P{} 的已分配资源 Max：".format(i)).split()
        allocation[i] = np.array(temp, dtype=int)

        if (max_table[i] < allocation[i]).any():
            print("[ERROR] 输入有误，重新输入")
            i -= 1

    # 导入测试数据，不用一次次手动输入
    # available, max_table, allocation = loadTestData()
    need = max_table - allocation

    # 计算出剩余资源
    for i in allocation:
        available -= i

    printTable(available, max_table, allocation, need)

    while (need != 0).any():
        proc_ind, req = input("输入请求，如：P1, 1 0 1: ").split(',')
        proc_ind = int(proc_ind[1:])
        req = np.array(req.split(), dtype=int)

        # 判断合法性
        if (req > max_table[proc_ind]).any():
            print("[ERROR] 输入有误，重新输入")

        # 判断安全性
        else:
            available -= req
            allocation[proc_ind] += req
            need[proc_ind] -= req
            if security(available.copy(), need, allocation):
                printTable(available, max_table, allocation, need)
                continue
            else:
                print("[ERROR] 不安全，不能分配")
                available += req
                allocation[proc_ind] -= req
                need[proc_ind] += req


if __name__ == '__main__':
    main()

[1] 西安电子科技大学出版社《计算机操作系统（第四版）》汤子瀛等编著

Xerrors
关注
  • 14
    点赞
  • 踩
  • 140
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
银行家算法的python实现
04-27
用python写的银行家算法
银行家算法（Python实现）
魚肉的博客
10-30 1260
【代码】银行家算法（Python实现）
银行家算法之Python实现[操作系统实验]
SylvanDing's Blog
05-31 5361
银行家算法 银行家算法是著名的死锁避免算法，其思想是：把操作系统视为银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。操作系统按照银行家制定的规则为进程分配资源。进程运行之前先声明对各种资源的最大需求量，当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过该进程声明的最大需求量。若超过则拒绝分配资源，若未超过则再测试系统现存的资源能否满足该进程尚须的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。 问题描述
操作系统——银行家算法 python实现
kindness_Chen的博客
07-03 6597
文章目录一、实现内容二、流程图三、实现思路四、完整代码及输出 一、实现内容 死锁会引起计算机工作僵死，因此操作系统中必须防止。本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。 设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。 系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析； 参考书籍：计算
Python实现银行家算法(使用numpy)
a256074653的博客
04-13 2678
银行家算法 这里把数据都写死了 使用的是西安电子科技大学出版社的计算机操作系统(第四版)第113页的表格的数据 # 银行家算法 import numpy as np def bank(n, m) -> bool: # 可利用资源向量,是一个含有m个元素的数组,代表系统中可利用资源的数目 Available = np.array([3, 3, 2], dtype=np.int32) # 最大需求矩阵Max,是一个n×m的矩阵,定义系统中n个进程中的每一个进程对m类资源的最大
银行家算法-----Python实现
WXjzcccc的博客
12-02 1746
银行家算法（Banker's Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。----百度百科 实验要求-----从文件读取数据并输入到文件当中 由于只实现这么一个功能，干脆不分函数了，直接顺下来。 源码po出 available = []#资源向量 proc = []#进程 allocation = []#分配矩阵 max_ = []#最大
银行家算法python实现
03-26
保证能跑
操作系统之银行家算法源代码
01-20
银行家算法是避免死锁的一种重要方法，本程序用java编程语言对其进行了实现。 当用户申请一组资源时，系统必须做出判断，如果把这些资源分出去，系统是否还处于安全状态。 若是，就可以分出这些资源；否则，该申请暂...
操作系统银行家算法课程设计
02-26
操作系统中的“银行家算法”是一种著名的资源分配策略，它的主要目标是确保系统的安全性，避免死锁的发生。在本课程设计中，我们将深入探讨这一关键概念，并通过实际编程实现来加深理解。 首先，银行家算法源于银行...
银行家算法模拟实现.zip
07-15
- 程序设计：使用编程语言（如C++或Python）实现银行家算法的逻辑。 - 数据结构：如何表示进程、资源、需求和状态。 - 测试用例：设计多种场景来验证算法的正确性，包括安全状态和不安全状态。 - 结果分析：展示...
banker.py-银行家算法
05-21
用python3.1写的银行家算法，主要用了类，数据类型为列表
Python实现银行家算法
最新发布
m0_62378244的博客
12-29 2361
首先先进行各个元素的比较，若满足条件，则在这个位置上填True，否则填False，最终得到这样具有真假值的矩阵，再通过all方法与这个矩阵的每一个元素作and运算，得到最终比较结果（all方法中的axis参数确定轴，对于矩阵，axis=1代表列，axis=0代表行）。在操作系统中研究资源分配策略时也有类似问题，系统中有限的资源要供多个进程使用，必须保证得到的资源的进程能在有限的时间内归还资源，以供其他进程使用资源。显然，每个进程的资源需求总量不能超过系统拥有的资源总数，银行算法进行资源分配可以避免死锁。
Python 实现OS银行家算法
qq_60293814的博客
11-19 1861
使用python语言实现操作系统中的银行家算法实验报告
python银行家算法_Python实现银行家算法
weixin_39552286的博客
12-04 664
import copy#初始化函数def bank_init():Process = [0]#安全性算法函数def bank_safe(Available,Need,Allocation,Pn):#创建Work数组 初始值为AvaliableWork = copy.deepcopy(Available)#创建Finish数组 默认设为全0 (False)Finish = [0]*Pn#创建安全序列...
银行家算法Python实现
qq_43271202的博客
10-18 6264
银行家 算法 银行家算法属于避免死锁的一种算法。 基本原理 银行家算法：当一个新进程进入系统时，该进程必须申明在运行过程中所需要的每种资源的最大数目，且该数目不能超过系统拥有的资源总量。当进程请求某组资源时，系统必须先确定系统中是否有足够的该类资源供以分配给该进程。若有，通过安全性算法来计算，将资源分配给该进程后，是否会使系统处于不安全状态，如果不会处于安全状态，则将资源分配给该进程，否则让进程等...
银行家算法的Python实现
seTaire的博客
03-09 1803
'''银行家算法 Dijkstra在1965年提出的银行家算法是著名的死锁避免算法 博客地址：https://www.cnblogs.com/wkfvawl/p/11929508.html ''' import pandas as pd class Bank: def __init__(self, **resources: int): ''' @param: resources 资源的数量 ''' ...
python银行家算法_银行家算法 Python实现
weixin_29015483的博客
01-30 1171
import random as rmm = eval(input("请输入所要创建进程的个数:"))n = eval(input("请输入系统资源种类数："))max1 = [[0 for j in range(n)]for i in range(m)]allocation = [[0 for j in range(n)] for i in range(m)]need = [[0 for j i...
死锁的处理策略——避免死锁
LOOKTOMMER的博客
12-06 2018
什么是安全序列 所谓安全序列，就是指如果系统按照这种序列分配资源，则每个进程都能顺利完成。只要能找出一个安全序列，系统就是安全状态。当然，安全序列可能有多个。 如果分配了资源之后，系统中找不出任何一个安全序列，系统就进入了不安全状态。这就意味着之后可能所有进程都无法顺利的执行下去。当然，如果有进程提前归还了一些资源，那系统也就有可能重新回到安全状态，不过我们在分配资源之前总是要考虑到最坏的情况。 如果系统处于安全状态，就一定不会发生死锁。如果系统进入了不安全状态，就可能发生死锁（处于不安全状态未必..
python实现银行家算法 操作系统
10-27
以下是Python实现银行家算法的代码示例： ``` def banker_algorithm(available, max, allocation): n = len(available) need = [] for i in range(n): need.append([max[i][j] - allocation[i][j] for j in ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值