操作系统优先级算法调度和最高响应比调度python实现

最新推荐文章于 2024-05-20 20:26:39 发布

赵药师

最新推荐文章于 2024-05-20 20:26:39 发布

阅读量1.6k

点赞数 3

文章标签： python 算法开发语言

本文链接：https://blog.csdn.net/qq_37040743/article/details/127554226

版权

优先级：计算先到达的第一个程序，先使用cpu，服务时间减一，如果后到的程序优先级高，则优先级高的抢占cpu。基本上第一个进程只能用一秒，因为下一秒到达的程序优先级，一把比它高。

import numpy as np
import os
import  random as rd
import time
class PCB:
    TIME=0#总时间
    def __init__(self, pid, arr_time,ser_time,pro,zhou,daizhou,aver_zhou,finish,aver_daizhou):#初始化
        self.finish=finish#需要服务的时间，常量，不改变
        self.pid = pid#进程号   
        self.arr_time = arr_time#到达时间
        self.ser_time=ser_time#仍需服务时间
        self.pro=pro#优先级
        self.zhou=zhou#周转时间
        self.daizhou=daizhou#带权周转时间
        self.aver_zhou=aver_zhou#平均周转时间
        self.aver_daizhou=aver_daizhou#平均带权周转
    def show(self):#输出信息
        for i in range (len(self.pid)):
            print("进程号",self.pid[i],"到达时间",self.arr_time[i],"\t","任需要服务时间",self.ser_time[i],"\t","优先级",self.pro[i],"\t","周转时间",self.zhou[i],"\t","带权周转时间","\t",self.daizhou[i],"\t","平均周转时间",self.aver_zhou[i],"\t","平均带权周转时间",self.aver_daizhou[i])
        print("\n")
    def sort_pro(self):#优先级排序降序
        for t in range(len(self.pro)-1):
            for i in range(0, len(self.pro)-1):
                s_pro = self.pro[i]
                s_pid=self.pid[i]
                s_at=self.arr_time[i]
                s_st=self.ser_time[i]
                s_finish=self.finish[i]
                if (self.pro[i] < self.pro[i+1]):
                    self.pro[i] = self.pro[i+1]
                    self.pid[i]=self.pid[i+1]
                    self.arr_time[i]=self.arr_time[i+1]
                    self.ser_time[i]=self.ser_time[i+1]
                    self.finish[i]=self.finish[i+1]
                    
                    self.pro[i+1] =s_pro
                    self.arr_time[i+1] =s_at
                    self.pid[i+1] =s_pid
                    self.ser_time[i+1] =s_st                  
                    self.finish[i+1]=s_finish
    def sort_artime(self):#到达时间升序
        for t in range(len(self.pid)-1):
            for i in range(0, len(self.pid)-1):
                s_pro = self.pro[i]
                s_pid=self.pid[i]
                s_at=self.arr_time[i]
                s_st=self.ser_time[i]
                s_zhou=self.zhou[i]
                s_daizhou=self.daizhou[i]
                s_aver_zhou=self.aver_zhou[i]
                s_finish=self.finish[i]
                if self.arr_time[i] > self.arr_time[i+1]:
                    self.pro[i] = self.pro[i+1]
                    self.pid[i]=self.pid[i+1]
                    self.arr_time[i]=self.arr_time[i+1]
                    self.ser_time[i]=self.ser_time[i+1]
                    self.finish[i]=self.finish[i+1]

                    self.pro[i+1] =s_pro
                    self.arr_time[i+1] =s_at
                    self.pid[i+1] =s_pid
                    self.ser_time[i+1] =s_st
                    self.finish[i+1]=s_finish

    def diaoyong(self):
        PCB.sort_artime(self)
        self.TIME=self.arr_time[0]
        i=0
        while(True):#先到达的先去用cpu，后到达的如果有优先级高的，如果先到达的没用完，也要退出
            tiaozhuan=1#用于跳出总循环
            print("正在运行进程的pid：",self.pid[0])
            self.TIME=self.TIME+1
            self.ser_time[0]=self.ser_time[0]-1
            #self.zhou[0]=self.zhou[0]+1
           # time.sleep(1)
            for i in range(1,len(self.pid)):
                if((self.arr_time[i]<=self.TIME and self.pro[i]>self.pro[0]) or self.ser_time[0]==0):#查找已到达并且优先级高的进程,跳出循环
                    tiaozhuan=0;
                    break
            if(tiaozhuan==0):
                break
    def pro_diaoyong(self):
        PCB.sort_pro(self)#优先级排序
        while(True):            
            for i in range (len(self.pid)):
                if (self.arr_time[i]<=self.TIME):
                    #self.TIME=self.TIME+1                    
                    
                    self.TIME=self.TIME+self.ser_time[i]#总时间
                    self.zhou[i]=self.TIME-self.arr_time[i]#周转时间
                    self.daizhou[i]=round(((self.TIME-self.arr_time[i])/self.finish[i]),1)#带权周转时间
                    self.aver_zhou[i]=round((self.TIME-self.arr_time[i])/len(self.pid),1)#平均周转时间
                    self.aver_daizhou[i]=(((self.TIME-self.arr_time[i])/(self.finish[i]*len(self.pid))))#平均带权周转时间
                    self.ser_time[i]=0#服务时间设为0
                    PCB.show(self)
                    print("正在运行进程的pid：",self.pid[i])
                    time.sleep(0.5)
                    os.system("cls")#清屏
            break
#X=int(input("输入进程数"))
X=50
pid=[]
arr_time=[]
finsh=[]
ser_time=[]
pro_time=[]
daizhou=[]
zhou=[]
aver_zhou=[]
aver_daizhou=[]
for i in range (X):#随机生成进程

    x=rd.randint(10,30)
    y=rd.randint(1,7)
    z=rd.randint(1,10)
    ser_time.append(x)
    finsh.append(x)
    pro_time.append(y)
    pid.append(i)
    arr_time.append(z)
    daizhou.append(0)
    zhou.append(0)
    aver_zhou.append(0)
    aver_daizhou.append(0)
P=PCB(pid,arr_time,ser_time,pro_time,zhou,daizhou,aver_zhou,finsh,aver_daizhou)
P.show()
print("\n")
P.diaoyong()
P.show()
print("\n")
P.pro_diaoyong()
P.show()
print(P.TIME)

最高响应比：先找到最先到达的进程运行，运行后的进程响应比设为0，重新计算剩下进程响应比，选取最高响应比的程序继续运行。

import numpy as np
import os
import  random as rd
import time
class PCB:
    TIME=0#总时间
    
    def __init__(self, pid, arr_time,ser_time,zhou,daizhou,aver_zhou,finish,aver_daizhou,respond):#初始化
        self.finish=finish#服务时间
        self.pid = pid#进程号   
        self.arr_time = arr_time#到达时间
        self.ser_time=ser_time#仍要服务时间
        self.zhou=zhou#周转时间
        self.daizhou=daizhou#带权周转时间
        self.aver_zhou=aver_zhou#平均周转时间
        self.aver_daizhou=aver_daizhou#平均带权周转
        self.respond=respond#响应比
    def sort_artime(self):#到达时间 升序
        for t in range(len(self.pid)-1):
            for i in range(0, len(self.pid)-1):
                
                s_pid=self.pid[i]
                s_at=self.arr_time[i]
                s_st=self.ser_time[i]
                s_finish=self.finish[i]
                if self.arr_time[i] > self.arr_time[i+1]:
                    
                    self.pid[i]=self.pid[i+1]
                    self.arr_time[i]=self.arr_time[i+1]
                    self.ser_time[i]=self.ser_time[i+1]
                    self.finish[i]=self.finish[i+1]
                   
                    self.arr_time[i+1] =s_at
                    self.pid[i+1] =s_pid
                    self.ser_time[i+1] =s_st
                    self.finish[i+1]=s_finish
    """
    def sort_respond(self):#响应比 奖序，
        for t in range(len(self.pid)-1):
            for i in range(0, len(self.pid)-1):
                s_respond=self.respond
                s_pid=self.pid[i]
                s_at=self.arr_time[i]
                s_st=self.ser_time[i]
                s_finish=self.finish[i]
                if (self.respond[i] <self.respond[i+1]):
                    self.respond[i]=self.respond[i+1]
                    self.pid[i]=self.pid[i+1]
                    self.arr_time[i]=self.arr_time[i+1]
                    self.ser_time[i]=self.ser_time[i+1]
                    self.finish[i]=self.finish[i+1]
                   
                    self.respond[i+1]=s_respond
                    self.arr_time[i+1] =s_at
                    self.pid[i+1] =s_pid
                    self.ser_time[i+1] =s_st
                    self.finish[i+1]=s_finish
    """

    def show(self):#输出信息
        for i in range (len(self.pid)):
            print("进程号",self.pid[i],"到达时间",self.arr_time[i],"\t","任需要服务时间",self.ser_time[i],"响应比",self.respond[i],"\t","周转时间",self.zhou[i],"\t","带权周转时间","\t",self.daizhou[i],"\t","平均周转时间",self.aver_zhou[i],"\t","平均带权周转时间",self.aver_daizhou[i])
        print("\n")
    def respond1(self):#调用一次运行第一个进程
        PCB.sort_artime(self)
        self.TIME=self.TIME+self.arr_time[0]
        self.TIME=self.TIME+self.ser_time[0]
        self.zhou[0]=self.TIME-self.arr_time[0]      
        self.ser_time[0]=0
    def respondi(self,i):#后续调用
        
        #PCB.sort_artime(self)
        #self.TIME=self.TIME+self.arr_time[i]
        self.TIME=self.TIME+self.ser_time[i]
        
        self.zhou[i]=self.TIME-self.arr_time[i]#周转时间
        self.daizhou[i]=round(((self.TIME-self.arr_time[i])/self.finish[i]),2)#带权周转时间
        self.aver_zhou[i]=round((self.TIME-self.arr_time[i])/len(self.finish),2)#平均周转时间
        self.aver_daizhou[i]=(((self.TIME-self.arr_time[i])/(self.finish[i]*len(self.finish))))#平均带权周转时间
        

        
        self.ser_time[i]=0
    def count_respond(self): #计算响应比   
        for i in range(0,len(self.pid)):
            if(self.ser_time[i]==0):
                self.respond[i]=0
            else:
                self.respond[i]=round(((self.TIME-self.arr_time[i])/self.finish[i]),1)
              
    def diaoyong(self): 
        PCB.respond1(self)#运行最先到达的进程,执行一次
        while(True):
            
            PCB.show(self)#显示
            c=self.respond.index(max(self.respond))#找出最大响应比的进程位置
            print("正在运行进程的pid：",self.pid[c])
            PCB.respondi(self,c)#运行最高响应比程序
            c=sum(self.ser_time)#求任需服务时间的和，如果为0，则全部完成，跳出循环
            PCB.count_respond(self)#计算响应比
            time.sleep(1)
            os.system("cls")
            if(c==0):#仍需服务时间为0，执行
                break

#X=int(input("输入进程数"))
X=50
pid=[]
arr_time=[]
ser_time=[]
finish=[]
respond=[]
daizhou=[]
zhou=[]
aver_zhou=[]
aver_daizhou=[]
for i in range (X):#随机生成进程

    x=rd.randint(10,30)
    z=rd.randint(1,10)
    ser_time.append(x)
    finish.append(x)
    pid.append(i)
    arr_time.append(z)
    daizhou.append(0)
    zhou.append(0)
    aver_zhou.append(0)
    aver_daizhou.append(0)
    respond.append(0)
P=PCB(pid,arr_time,ser_time,zhou,daizhou,aver_zhou,finish,aver_daizhou,respond)
P.show()
print("\n")
P.diaoyong()
P.show()
print(P.TIME)

总结：初学操作系统，写这2个程序，只是为了简单的模拟一下这两种调度方法，所以有点投机取巧，把进程到达的时间设置的比较小，这样可以缩减一下代码，不用去管cpu空等。