银行家算法代码Python已知max,need,available求分配矩阵并找到安全序列

银行家算法是一种用于解决死锁问题的资源分配策略，在多进程或多线程系统中，它通过动态调整进程对资源的请求，避免了死锁的发生。当你有三个变量 `max` (最大可用资源总量)，`need` (进程当前需要的资源量)，`available` (当前剩余可用资源) 时，可以编写如下的Python代码来模拟银行家算法并找出安全序列：

def banker_algorithm(max_resources, needed_resources, available_resources):
    # 初始化全局状态变量
    deadlock = False
    safe_sequence = []

    # 定义工作队列和资源矩阵
    process_queue = [i for i in range(len(needed_resources))]
    resource_matrix = [[0] * len(max_resources)] + max_resources

    while process_queue and not deadlock:
        # 获取当前可用的最大进程
        current_process = process_queue[0]
        min_resource = float('inf')
        min_process = None
        for p in process_queue:
            if available_resources[p] < min_resource and available_resources[p] > 0:
                min_resource = available_resources[p]
                min_process = p

        # 检查是否有足够的资源给当前进程
        if min_resource <= needed_resources[current_process]:
            # 更新资源矩阵和队列
            for i in range(len(max_resources)):
                resource_matrix[current_process][i] += min_resource
                available_resources[min_process][i] -= min_resource
            process_queue.remove(min_process)
            safe_sequence.append(current_process)

        else:
            # 计算循环等待图，检查是否形成死锁
            circular_wait = False
            for p in process_queue:
                deadlock_p = True
                for r in range(1, len(resource_matrix[0])):
                    if resource_matrix[p][r] > 0 and resource_matrix[current_process][r] != 0:
                        deadlock_p &= resource_matrix[p][0] - resource_matrix[p][r] >= resource_matrix[current_process][0] - resource_matrix[current_process][r]
                if deadlock_p:
                    deadlock = True
                    break

            # 如果检测到死锁，则回滚操作
            if deadlock:
                for p in reversed(safe_sequence):
                    for i in range(len(max_resources)):
                        available_resources[p][i] += resource_matrix[p][i]
                        resource_matrix[p][i] = 0
                safe_sequence.clear()
                deadlock = False
                break

    return safe_sequence, deadlock

# 示例
max_resources = [[4, 5], [3, 6]]  # 例如两台机器，每台最多能提供4单位CPU和5单位内存
needed_resources = [[2, 3], [3, 2]]  # 第一个进程需要2CPU和3内存，第二个进程需要3CPU和2内存
available_resources = [[4, 5], [3, 6]]  # 初始状态下资源充足

solution = banker_algorithm(max_resources, needed_resources, available_resources)
safe_sequence, deadlock = solution
if deadlock:
    print("存在死锁，无法分配")
else:
    print(f"安全序列：{safe_sequence}")
    print(f"最终资源分配：{available_resources}")