银行家算法-----Python实现

银行家算法（Banker's Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。----百度百科

实验要求-----从文件读取数据并输入到文件当中

由于只实现这么一个功能，干脆不分函数了，直接顺下来。

源码po出

available = []#资源向量
proc = []#进程
allocation = []#分配矩阵
max_ = []#最大需求矩阵
need = []#需求矩阵
work = []#工作向量
finish = []
wpa = []#work+allocation
f = open("src.txt","r+")
fr = f.read()
for i in fr:
    if i == "\n":
        break
    if i != " ":
        available.append(i)#导入Available
n = len(available)#资源数目
str1 = fr.replace("\n"," ")
list = str1.split(" ")
for i in range(n,len(list),2*n+1):
    proc.append(list[i])#导入进程
tmp = 0
temp = n + 1
while temp < len(list):
    allocation.append(list[temp])#导入Allocation
    tmp+=1
    temp+=1
    if tmp == n:
        tmp = 0
        temp += n + 1
temp = 2*n+1
while temp < len(list):
    max_.append(list[temp])#导入MAX
    tmp+=1
    temp+=1
    if tmp == n:
        tmp = 0
        temp += n + 1
for i in range(len(max_)):
    need.append(eval(max_[i]) - eval(allocation[i]))#计算need
print("从",proc,"中选择一个请求进程",end=":")
start = input()
print("输入请求的资源(共{a}个，以空格区分)".format(a=n),end=":")
request_t = input()
request = request_t.split(" ")
index = 0
for i in range(len(proc)):
    if start == proc[i]:
        index = i
        break
flag = False
for i in range(n):
    if eval(request[i]) > need[i+index*n]:#步骤1判断
        flag = False
        break
    else:
        flag = True
        continue
if flag == True:
    for i in range(n):
        if eval(request[i]) > eval(available[i]):#步骤2判断
            flag = False
            break
        else:
            flag = True
            continue
if flag == True:
    for i in range(n):#步骤3修改资源
        available[i] = eval(available[i]) - eval(request[i])
        allocation[i+index*n] = eval(allocation[i+index*n]) + eval(request[i])
        need[i+index*n] = need[i+index*n] - eval(request[i])
    work = available
    work_str = [0]*n*len(proc)
    finish = [False]*len(proc)
    for i in range(len(allocation)):
        allocation[i] = str(allocation[i])
        allocation[i] = eval(allocation[i])
    queue = []#安全序列
    for i in range(len(proc)):#安全性检查
        for index_t in range(len(proc)):
            if index_t not in queue:
                if finish[index_t] == False:
                    flag_t = True
                    for j in range(n):
                        if need[j+index_t*n] > work[j]:#判断need[i][j]≤work[j]
                            flag_t = False
                            break
                    if flag_t == True:
                        for j in range(n):
                            work_str[j+index_t*n] = work[j]
                            work[j] = work[j] + allocation[j+index_t*n]
                        queue.append(index_t)
                        finish[index_t] = True
    for i in finish:
        if i == False:
            flag = False
            break
    for i in range(len(work_str)):
        wpa.append(work_str[i]+allocation[i])
    if flag == True:
        with open("yhj_res.txt","w",encoding="utf-8") as ff:
            ff.write("\t进程\twork\tallocation\tneed\twork+allocation\tfinish\n")
            res_list = []
            for i in queue:
                ff.write("\t"+str(proc[i]))
                ff.write("\t"+str(work_str[i*n:i*n+n]))
                ff.write("\t"+str(allocation[i*n:i*n+n]))
                ff.write("\t"+str(need[i*n:i*n+n]))
                ff.write("\t"+str(wpa[i*n:i*n+n]))
                ff.write("\t   "+str(finish[i])+"\n")
                res_list.append(proc[i])
            ff.write("可以分配，存在安全序列"+str(res_list))
            print("可以分配，存在安全序列"+str(res_list))
    else:
        with open("yhj_res.txt","w",encoding="utf-8") as ff:
            ff.write("无法分配")
            print("无法分配")
    f.close()
    ff.close()

源文件内容---src.txt 

其中，第一行的1 6 2 2表示给出的Available为[1,6,2,2]，后面5行的第1列表示进程的名称，根据Available的长度为4，后四列为Allocation，最后4列为Max。

1 6 2 2
a 0 0 3 2 0 0 4 4
b 1 0 0 0 2 7 5 0
c 1 3 5 4 3 6 10 10
d 0 3 3 2 0 9 8 4
e 0 0 1 4 0 6 6 10

测试

输出结果到文件yhj_res.txt

	进程	work	       allocation	    need	    work+allocation	   finish
	a	[1, 5, 1, 2]	[0, 0, 3, 2]	[0, 0, 1, 2]	[1, 5, 4, 4]	   True
	d	[1, 5, 4, 4]	[0, 4, 4, 2]	[0, 5, 4, 2]	[1, 9, 8, 6]	   True
	e	[1, 9, 8, 6]	[0, 0, 1, 4]	[0, 6, 5, 6]	[1, 9, 9, 10]	   True
	b	[1, 9, 9, 10]	[1, 0, 0, 0]	[1, 7, 5, 0]	[2, 9, 9, 10]	   True
	c	[2, 9, 9, 10]	[1, 3, 5, 4]	[2, 3, 5, 6]	[3, 12, 14, 14]	   True
可以分配，存在安全序列['a', 'd', 'e', 'b', 'c']