设计3-4个并发进程，共享系统的10个同类不可抢占资源，各进程按银行家算法动态进行资源的申请和释放，编写程序模拟执行这一过程

设计这样的并发进程系统，并使用银行家算法，我们可以创建以下几个步骤：

1. 定义进程和资源池：
- 创建5个进程（编号1到5），每个进程都有对10个资源的需求，初期状态都是空闲。
- 假设有10个资源类型，每个类型只有一个。

2. 初始化数据结构：
- 银行家算法需要矩阵（B[][], L[], M[][], P[][])存储各个进程的状态、最大需求、可用量以及请求值。

3. 实现银行家算法函数：
- 银行家算法的核心部分包括检查安全序列（满足“资源可用 + 每个进程最多需要的资源 <= 总资源”条件）、分配资源和回收资源。

def is_safe(B, L, M, P):
    max_reqs = [sum(P[i]) for i in range(len(P))]
    available = [B[i][j] - M[i][j] for i in range(len(M)) for j in range(10)]
    return all(available[j] >= max_reqs[k] for k, j in enumerate(L))

def allocate_resource(B, L, M, P):
    while True:
        # 如果能找到一个安全序列，分配资源
        if is_safe(B, L, M, P):
            for i, p in enumerate(P):
                if p[0]:
                    B[i][p[0]] -= 1
                    break
            break
        else:
            # 否则，尝试回退一个进程
            for i, p in reversed(tuple(enumerate(P))):
                if p[0]:
                    B[i][p[0]] += 1
                    break

def release_resource(B, L, M, P):
    for i, (req, used) in enumerate(zip(P, B)):
        if req[0]:
            B[i][req[0]] += 1

4. 主循环模拟进程调度：
- 循环处理每个进程的申请、释放操作，直到所有资源都被占用并释放。

resources = [[True] * 10 for _ in range(10)]  # 初始资源状态
P = []  # 初始化进程列表，记录进程的状态和资源请求

for _ in range(5):  # 添加进程
    P.append([True, 0] * 10)

while not all(not p[0] for p in P):
    for process in P:
        if process[0]:  # 进程有申请
            allocate_resource(resources, L, M, P)
            process[0] = False  # 更新进程状态
        elif process[1]:  # 进程有释放
            release_resource(resources, L, M, P)
            process[1] = False