一、前言
笔者看来，这个实验主要是模拟进程的状态转换以及与资源的关系。
因此难度说不上很大，但是比较复杂，这里上传一份python版本供大家参考，疏漏之处还请不吝赐教。
二、基本流程
因为在本实验程序中先来先服务视为最高优先级的一种子情况，因此只分析最高优先级即可。
1、创建进程：按照预定的序号id、优先级pri等五项创建进程。
2、创建资源：同理，根据序号rid、状态state等三项创建资源。
3、尝试运行所有进程，最终一定是优先级最高的运行，其他进程按照优先级在ready队列中排队。
4、申请资源，若资源为空，则占用，否则加入此资源的等待队列中排队；
5、释放资源，释放后若有进程等待，则立即将资源重新分配下去。
6、删除进程，删除进程关于资源的引用以及资源队列中的进程信息。
三、源代码
class PCB(object):
class Struct(object):
def __init__(self,id,mem,src,state,tree,pri):
self.id = id #int 序号
self.mem = mem #list 内存
self.src = src #list 其他资源
self.state = state #(int,int) （状态类型，列表位置）
self.tree = tree #(int,int) （父节点id，子节点id）0表示没有父子节点
self.pri = pri #int （优先级）
def make_struct(self,id,mem,src,state,tree,pri):
return self.Struct(id,mem,src,state,tree,pri)
def delete_p(self,p):
del p
class RCB(object):
class Struct(object):
def __init__(self,rid,state,queue):
self.rid = rid #int 资源序号,大于0表示内存资源，小于0表示其他资源
self.state = state #int 状态,0空闲，1占用
self.queue=queue #Queue 等待队列
def make_struct(self,rid,state,queue):
return self.Struct(rid,state,queue)
#用于优先级排序
def way(elem):
return elem.pri
#创建线程
def create_pro(pcb,ready_queue,parameter):
id,mem,src,state,tree,pri=parameter[0],parameter[1],parameter[2],parameter[3],parameter[4],parameter[5]
p1=pcb.make_struct(id,mem,src,state,tree,pri)
ready_queue.append(p1)
#根据优先级从大到小排序
ready_queue.sort(key=way,reverse=True)
return p1
#运行线程
def run_pro(p,ready_queue,running_queue):
if len(running_queue)==0:
ready_queue.remove(p)
running_queue.append(p)
print(p.id,"运行成功！")
elif len(running_queue)==1:
#如果原进程的优先级更高
if(running_queue[0].pri>p.pri):
print("原进程",running_queue[0].id,"的优先级更高，",p.id,"无法抢占运行！")
elif(running_queue[0].pri==p.pri):
print(running_queue[0].id,"与",p.id,"优先级相同，",p.id,"无法抢占运行,需要排队！")
else:
print(p.id,"的优先级更高，",running_queue[0].id,"被抢占运行！")
ready_queue.append(running_queue[0])
running_queue.remove(running_queue[0])
ready_queue.remove(p)
running_queue.append(p)
ready_queue.sort(key=way,reverse=True)
#挂起进程
def hang_up(p,ready_queue,block_queue,running_queue,hangup_queue):
if p in ready_queue:
ready_queue.remove(p)
hangup_queue.append(p)
elif p in block_queue:
block_queue.remove(p)
hangup_queue.append(p)
elif p in running_queue:
running_queue.remove(p)
hangup_queue.append(p)
else:
print(p," already in hangup_queue;")
#激活进程
def act_pro(p,block_queue,hangup_queue):
hangup_queue.remove(p)
block_queue.append(p)
#删除线程(即将p从引用、队列中删除)
def delete_pro(p,pcb,rcb,ready_queue,block_queue,running_queue,hangup_queue):
pcb.delete_p(p)
for r in rcb:
if p.id in r.queue:
r.queue.remove(p.id)
print("已删除",p.id,"对资源",r.rid,"的占用！")
for mem in p.mem:
p.mem.remove(mem)
print(p.id,"已经释放关于",mem,"的信息")
if p in ready_queue:
ready_queue.remove(p)
elif p in block_queue:
block_queue.remove(p)
elif p in running_queue:
running_queue.remove(p)
elif p in hangup_queue:
hangup_queue.remove(p)
else:
print(p," don't exists;")
def show(rcb,ready_queue,block_queue,running_queue,hangup_queue):
print("当前系统状态如下(进程id:[内存资源],[其他资源],优先级)：")
print("ready_queue:")
for p in ready_queue:
print(p.id,":",p.mem,",",p.src,",",p.pri,"\t")
print("block_queue:")
for p in block_queue:
print(p.id,":",p.mem,",",p.src,",",p.pri,"\t")
print("running_queue:")
for p in running_queue:
print(p.id,":",p.mem,",",p.src,",",p.pri,"\t")
print("hangup_queue:")
for p in hangup_queue:
print(p.id,":",p.mem,",",p.src,",",p.pri,"\t")
for r in rcb:
print("资源",r.rid,"中的使用队列如下：[",end=" ")
for p in r.queue:
print(p.id,end=" ")
print("]")
print("*****************************************************")
#申请资源
def apply_rsc(r,p,running_queue,ready_queue,block_queue):
if p in running_queue:
running_queue.remove(p)
if r.state==0:
r.state=1
if r.rid<0:
p.src.append(r.rid)
elif r.rid>0:
p.mem.append(r.rid)
r.queue.append(p)
ready_queue.append(p)
print(p.id,"申请资源",r.rid,"成功！")
if len(running_queue)==0:
if len(ready_queue)>=1:
running_queue.append(ready_queue[0])
ready_queue.remove(ready_queue[0])
print(p.id,"因申请资源被移出运行状态，申请成功而加入就绪队列！而",running_queue[0].id,"进入运行状态！")
ready_queue.sort(key=way,reverse=True)
else:
print(p.id,"因申请资源被移出运行状态，因当前没有就绪进程而特此提示！")
else:
block_queue.append(p)
r.queue.append(p)
print(p.id,"申请资源",r.rid,"时失败,但已经加入队列中")
r.queue.sort(key=way,reverse=True)
elif p in block_queue:
if r.state==0:
r.state=1
if r.rid<0:
p.src.append(r.rid)
elif r.rid>0:
p.mem.append(r.rid)
if p not in r.queue:
r.queue.append(p)
print(p.id,"申请资源",r.rid,"成功！")
else:
block_queue.append(p)
r.queue.append(p)
r.queue.sort(key=way,reverse=True)
print(p.id,"申请资源",r.rid,"时失败,但已经加入队列中")
else:
print(p.id,"既不在运行也不在等待队列中，不能申请资源",r.rid,"!")
#释放资源
def release_rsc(r,p,running_queue,ready_queue,block_queue):
if p in r.queue:
if r.queue[0]==p:
r.state=0
r.queue.remove(p)
if r.rid>0:
p.mem.remove(r.rid)
elif r.rid<0:
p.src.remove(r.rid)
print(p.id,"释放资源",r.rid,"成功！")
#释放资源后,若有等待使用，则分配给等待进程
if len(r.queue)>0:
apply_rsc(r,r.queue[0],running_queue,ready_queue,block_queue)
elif r.state==1:
print(p.id,"无法释放资源",r.rid,"，因为还没有排上！")
else:
print(p.id,"释放资源",r.rid,"时失败")
else:print(p.id,"不占用资源",r.rid,"，无需释放！")
if __name__=='__main__':
#初始化创建队列以及配置资源
pcb=PCB()
ready_queue=[]
block_queue=[]
running_queue=[]
hangup_queue=[]
#id,mem,src,state,tree,pri
pro1=[1,[],[],(5,3),(0,2),5]
pro2=[2,[],[],(5,3),(1,0),4]
pro3=[3,[],[],(5,3),(1,0),6]
#rid,state,queue
rcb1=[1,0,[]]
rcb2=[2,0,[]]
rcb3=[-1,0,[]]
r1=RCB().make_struct(rcb1[0],rcb1[1],rcb1[2])
r2=RCB().make_struct(rcb2[0],rcb2[1],rcb2[2])
r3=RCB().make_struct(rcb3[0],rcb3[1],rcb3[2])
rcb=[]
rcb.append(r1)
rcb.append(r2)
rcb.append(r3)
#开始模拟系统操作,创建进程p1,p2
p1=create_pro(pcb,ready_queue,pro1)
p2=create_pro(pcb,ready_queue,pro2)
p3=create_pro(pcb,ready_queue,pro3)
print("创建完进程后的系统状态如下：")
show(rcb,ready_queue,block_queue,running_queue,hangup_queue)
#尝试运行进程
run_pro(p1,ready_queue,running_queue)
run_pro(p2,ready_queue,running_queue)
run_pro(p3,ready_queue,running_queue)
print("尝试运行完进程后的系统状态如下：")
show(rcb,ready_queue,block_queue,running_queue,hangup_queue)
#申请资源
apply_rsc(r1,p3,running_queue,ready_queue,block_queue)
apply_rsc(r2,p3,running_queue,ready_queue,block_queue)
apply_rsc(r1,p1,running_queue,ready_queue,block_queue)
apply_rsc(r3,p1,running_queue,ready_queue,block_queue)
apply_rsc(r2,p1,running_queue,ready_queue,block_queue)
print("申请完资源后的系统状态如下：")
show(rcb,ready_queue,block_queue,running_queue,hangup_queue)
#释放资源
release_rsc(r1,p3,running_queue,ready_queue,block_queue)
release_rsc(r2,p1,running_queue,ready_queue,block_queue)
release_rsc(r3,p2,running_queue,ready_queue,block_queue)
print("释放完资源后的系统状态如下：")
show(rcb,ready_queue,block_queue,running_queue,hangup_queue)
##最终删除所有进程
delete_pro(p1,pcb,rcb,ready_queue,block_queue,running_queue,hangup_queue)
delete_pro(p2,pcb,rcb,ready_queue,block_queue,running_queue,hangup_queue)
delete_pro(p3,pcb,rcb,ready_queue,block_queue,running_queue,hangup_queue)
print("删除完所有进程后，最终系统状态如下：")
show(rcb,ready_queue,block_queue,running_queue,hangup_queue)
input("输入回车退出")
四、运行截图
