栗子如下：

在银行家算法中，若出现下述资源分配情况：
这里写图片描述，

Process代表进程， Allocation代表进程已占用资源数，Need代表进程还需多少资源才能结束释放资源

Avaiable代表当前系统可用资源

    注：题中共四种资源，P0的Allocation为（0，0，3，2）表示已分配给P0的第一种资源和第二种资源为0个，第三种资源3个，第四种资源2个。

（1）该状态是否安全？

（2）若进程P2提出请求Request（1，2，2，2）后，系统能否将资源分配给它？

如何解决？

系统安全吗？

将已占有资源（Allocation）和剩余资源（Avaible）相加可以得到总资源，假设资源为 A B C D

         那么总资源为 {'A':3,'B':12,'C':14,'D':14}

第一步：看 进程需要资源数（Need）小于可用资源数（Avaible）的进程，

那么只有进程 P0 满足

第二步：将P0进程释放，此时可用资源数要(1,6,2,2)加上P0之前占有的资源数( 0 0 3 2)，

 故P0释放后可以资源数（Avaible）为(1,6,5,4)

第三步：在剩下的进程里面，看进程需要资源数（Need）小于当前可以资源数（Avaible）（1，6，5，4）

那么我们找到P3,释放P3后可以资源数又为（1，6，5，4） + （0，3，3，2）

依次步骤下去，可得到安全序列 P0,P3,P4,P1,P2 ，故系统安全

P2发出请求向量Request(1,2,2,2),此操作安全吗？

①Request2(1,2,2,2)<=Need2(2,3,5,6)
②Request2(1,2,2,2)<=Available(1,6,2,2)
③系统先假定可为P2分配资源，并修改Available，Allocation2和Need2向量：
Available=(0,4,0,0)
Allocation2=(2,5,7,6)
Need2=(1,1,3,4)
此时再进行安全性检查，发现 Available=(0,4,0,0) 不能满足任何一个进程，所以判定系统进入不安全状态，即不能分配给P2相应的Request(1,2,2,2)。

Python如何解决？

'''
两大功能模块
1.给出进程数，资源数，进程需要资源数，进程已占有资源数，给出是否安全，若安全给出安全序列
2.模拟里面进程请求资源，预测本次操作是否安全
'''

import copy

#模拟进程请求资源
def simulationReques(process_id,request_dict):
    print('Now Allocation:',allocation)
    #最大请求数 >= 请求数 ？
    if not compareDict(max[process_id],request_dict):
        print('请求资源过大，拒绝')
        return False
    #可用资源 >= 请求数？
    if not compareDict(avaiable,request_dict):
        print('无足够资源分配，拒绝')
        return False
    #分配资源
    subtractionDict(avaiable,request_dict)#可用资源减少
    addDict( allocation[process_id],request_dict)#进程占用资源增加
    subtractionDict( need[process_id],request_dict)#进程需要资源减少

    #系统安全性检查
    if calculateSafe(avaiable,need,allocation,pn):
        print('okay')
    else:
        addDict(avaiable, request_dict)
        subtractionDict(allocation[process_id], request_dict)
        addDict(need[process_id], request_dict)
    return allocation



#安全性算法函数
#avaible-可用资源,need--需要资源,allocation-已占有资源,pn-进程数
def calculateSafe(avaiable,need,allocation,pn):
    #copy 可用资源数
    avaible_work = copy.deepcopy(avaiable)
    #创建完成数组，默认设为全0-False
    finsh_arr = [0] * pn
    #创建安全序列
    safe_queue = []
    #循环5次
    count = 0
    print('Avaiable_Work:',avaible_work)
    print('Finsh_Arr:',finsh_arr)
    print('Safe_Queue:',safe_queue)
    while count < pn:
        #按进程编号找到一个可安全加入进程的进程
        i = 0
        while i < pn:
            # 该进程未完成模拟
            if not finsh_arr[i]:
                #可用资源 >= 请求资源 ？
                is_safe = compareDict(avaible_work,need[i])
                if is_safe:#如果成功
                    # 更新安全队列
                    safe_queue.append(i)
                    # 更新完成值
                    finsh_arr[i] = True
                    # 更新可用资源 = 当前可用 + 当前进程释放资源
                    addDict(avaible_work,allocation[i])

            i += 1
        count += 1
    print('Avaiable_Work:', avaible_work)
    print('Finsh_Arr:', finsh_arr)
    print('Safe_Queue:', safe_queue)
    if len(safe_queue) == pn:
        print('系统处于安全状态，计算得出安全序列',safe_queue)
        return True
    print('不安全')
    return False



#比较两个字典,如果a>=b返回true
def compareDict(a,b):
    flag = True
    for key in a.keys():
        if a[key] < b[key]:
            return False
    return flag
#两个字典相加a的值增加b的值
def addDict(a,b):
    for key in a.keys():
        a[key] = a[key] + b[key]
#两个字典相减 a的值减少b的值
def subtractionDict(a,b):
    for key in a.keys():
        a[key] = a[key] - b[key]





if __name__ == '__main__':
    #进程数 = 下面数组的长度
    pn = 5
    #各种资源总资源数
    avaiable = { "A":3,"B":12,'C':14,'D':14}
    #每个进程对各种资源的最大需求
    max = [
        {"A": 0, "B": 0, 'C': 4, 'D': 4},
        {"A": 2, "B": 7, 'C': 5, 'D': 0},
        {"A": 3, "B": 6, 'C': 10, 'D': 10},
        {"A": 0, "B":9, 'C': 8, 'D': 4},
        {"A": 0, "B": 6, 'C': 6, 'D': 10}
    ]
    #各个进程已占有的资源数
    allocation = [
        {"A": 0, "B": 0, 'C': 3, 'D': 2},
        {"A": 1, "B": 0, 'C': 0, 'D': 0},
        {"A": 1, "B": 3, 'C': 5, 'D': 4},
        {"A": 0, "B": 3, 'C': 3, 'D': 2},
        {"A": 0, "B": 0, 'C': 1, 'D': 4}
    ]

    #得到进程资源的需求数 = 最大需求 - 已占有
    need = []
    cn = 0
    for i in range(pn):
        tmp = copy.deepcopy(max[i])
        subtractionDict(tmp,allocation[i])
        need.append(tmp)
        cn += 1
    print('Need:',need)
    #各个资源的可用数量 = 资源总数 - 已占有
    for allo in allocation:
        subtractionDict(avaiable,allo )
    print("Avaiable:",avaiable)

    #调用方法，判断当前进程是否安全
    calculateSafe(avaiable, need, allocation, pn)

    #模拟P2进程请求资源
    args_process_id = 2
    args_request_dict = {'A': 1, 'B': 2, 'C': 2, 'D': 2}#请求资源数情况
    print(simulationReques(args_process_id, args_request_dict))