操作系统——作业调度算法 python实现

一、实现内容

（1） 编写并调试一个单道处理系统的作业调度模拟程序。
　　作业调度算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRRN）的调度算法。
　　对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，以比较各种算法的优缺点。
（2） 编写并调度一个多道程序系统的作业调度模拟程序。
　　作业调度算法：采用基于先来先服务的调度算法或基于优先级的作业调度算法。其余可以参考课本中的方法进行设计。
　　对于多道程序系统，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。

二、流程图

（1）程序基本要求

在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的 CPU时限等因素。
　　作业调度算法：采用先来先服务（FCFS）调度算法，即按作业提交的先后次序进行调度。总是首先调度在系统中等待时间最长的作业。每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
　　作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W。各个等待的作业按照提交时刻的先后次序排队，总是首先调度等待队列中队首的作业。每个作业完成后要打印该作业的开始运行时刻、完成时刻、周转时间和带权周转时间，这一组作业完成后要计算并打印这组作业的平均周转时间、带权平均周转时间。

（2）流程图

三、实现思路

单道系统模拟

（1）在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的 CPU时限等因素

（2）高响应比怎么体现？
在进程调度中，pcb类中添加了2个和优先级有关的类属性，静态优先级prior和动态优先级dy_prior。那在JCB类中，并不需要显示初始的优先级，因为初始的优先级一定为0，所以可以将动态优先级这个属性删除，随着作业调度，执行作业的操作的时间变化，每次执行完上一个作业就计算当前的各个作业的优先级，并赋值prior。

（3）SJF算法也很简单，虽然多了一个优先级的概念，但是一个确定作业序列中，每个作业的所需时长已知，那我干脆将这个作业序列，按照每个序列的时长，从小到大排列，然后再进行FCFS的调度就好了。

（4）HRRN响应比高者优先调度算法也是按照优先级先后调度，这里的优先级和SJF不同，这肯定是动态变化的，有点类似动态优先级调度，但是更简单。这里的优先级=（等待时间+要求服务时间）/要求服务时间。等待的时间和所需要的时间的和刚好是系统对该作业的响应时间。而这个比值看分母，说明该算法还是偏袒时间短的作业，等待时间相同时，作业越短，获得执行的几率越高。
因为每次都要计算优先级，所以就没法直接对序列循环了。更类似实验一的算法了。

我是这么解决的，每次都执行序列首部的作业。在执行了上一个作业后，将执行完的作业移动位置到序列尾部，然后对剩下的len(list)-len(state=finish)个挑选当前优先级最大的到序列首部。都是O(n)个复杂度。

而id=0的就是默认的t0=0时，等待时间最长的，所以虽然一开始首部的优先级是0，但是他应该是第一个执行的

多道系统模拟

四、完整代码及输出

（1）单道系统作业调度模拟

import random
##这是单道处理系统作业的调度模拟，包括FCFS(先来先服务)、SJF(短作业优先)、HRRN(响应比高着优先)算法。
class JCB :
    def __init__(self, id, cputime) :
        # id:序号  cputime:作业预计所需时间
        self.id = id
        self.prior = 0      #可作为HRRN中需要的优先级，一开始为0，随着调度、等待而改变；
        self.cputime = cputime
        self.state = 0  # 0表示Wait 1表示Run 2表示Finish
        self.starttime = 0    #进程开始运行的时间
        self.endtime = 0     #进程结束运行时间

    def out_init(self):
        print(("初始化JCB序列:%-2d" + "预计所需时间:%-2d")%(self.id,self.cputime))

    def outSituation_HRRN(self) :  #输出HRRN法作业调度情况
        Turnaround = self.endtime   #周转时间= 完成时间-提交时间
        Daiquan = Turnaround / self.cputime  #带权周转时间：周转时间/运行所需时间
        print(("HRRN法： "+"作业:%-2d"  +"  优先权:%-2d"+ "  作业所需CPU时间:%-2d" +"  开始运行时间:%-2d"
               + "  结束运行时间:%-2d" +"  周转时间:%.2f" + "  带权周转时间:%.2f")%
              (self.id,self.prior,self.cputime,self.starttime,self.endtime,Turnaround, Daiquan))

    def outSituation_FCFS(self) :  #输出FCFS法作业调度运行情况
        Turnaround = self.endtime
        Daiquan = Turnaround / self.cputime
        print(("FCFS： " + "作业:%-2d" + "  作业所需CPU时间:%-2d" + "  开始运行时间:%-2d"
               + "  结束运行时间:%-2d"+"  周转时间:%.2f" + "  带权周转时间:%.2f") %
              (self.id, self.cputime, self.starttime, self.endtime,Turnaround, Daiquan))

    def outSituation_SJF(self) :  #输出SJF法作业调度运行情况
        Turnaround = self.endtime
        Daiquan = Turnaround / self.cputime
        print(( "SJF法： "+"作业:%-2d" + "  作业所需CPU时间:%-2d" + "  开始运行时间:%-2d"
               + "  结束运行时间:%-2d"+"  周转时间:%.2f" + "  带权周转时间:%.2f") %
              (self.id, self.cputime, self.starttime, self.endtime,Turnaround, Daiquan))

def init(num) : #创建数目确定的jcb块，按顺序放入列表中
    jcbList = []
    for i in range(num) :
        jcbList.append(JCB(i, random.randint(1, 20)))
        # 将随机产生的n个作业保存，创建id和预计CPU时间
    print("刚生成的各进程")
    for i in jcbList:  #输出最开始时进程情况
        i.out_init()
    return jcbList

def sort_SJF(jcbList):  #将初始化的序列，按照作业的时间，从小到大排列。
    for i in range(0,len(jcbList)-1):
        for j in range(i+1,len(jcbList)):
            if jcbList[i].cputime > jcbList[j].cputime :
                jcbList[i],jcbList[j] = jcbList[j],jcbList[i]
    return jcbList

def sort_HRRN(jcbList,count): #每次执行完上一个作业，对剩余作业排序，响应比作为优先级，优先级高的排前面
    #优先级=（等待时间+cputime）/cputime  这里的等待时间可以理解为就是时间量T,因为参与排序的肯定是还没执行的作业
    #先计算待处理的作业的优先级，将finish的排到最后，并且将优先级最高的排到第一位
    for i in jcbList:
        i.prior = (count + i.cputime)/i.cputime
    for i in range(len(jcbList)-1,0,-1): #finish的转移到尾部，然后只遍历状态为0的
        if jcbList[i].state == 2:
            continue
        if jcbList[i].prior > jcbList[i-1].prior :
            jcbList[i], jcbList[i - 1] = jcbList[i-1], jcbList[i]


def FCFS(jcbList): #先来先服务调度算法
    count = 0 #时间片0  即指导书中的时间量T0=0
    for i in jcbList:
        i.state = 1
        i.starttime = count   #每个作业只执行一次，所以不需要像实验一动态优先级算法一样来判断是否是第一次执行
        count += i.cputime
        i.endtime = count
        i.state = 2
        i.outSituation_FCFS()
    Turnaround_time = 0
    daiquan_time = 0
    for i in jcbList :  # 计算平均周转时间
        Turnaround_time += i.endtime   #完成时间-提交时间，因为排队的时候时间量为0，所以初始化时就当是0
        daiquan_time += i.endtime/i.cputime
    print(('平均周转时间：%.2f'+'  平均带权周转时间%.2f')%(Turnaround_time/len(jcbList),daiquan_time/len(jcbList)))


def SJF(jcbList):  #短作业优先调度算法
    count = 0
    sort_SJF(jcbList)
    for i in jcbList:
        i.state = 1
        i.starttime = count   #每个作业只执行一次，所以不需要像实验一动态优先级算法一样来判断是否是第一次执行
        count += i.cputime
        i.endtime = count
        i.state = 2
        i.outSituation_SJF()
    Turnaround_time = 0
    daiquan_time = 0
    for i in jcbList :  # 计算平均周转时间
        Turnaround_time += i.endtime   #完成时间-提交时间，因为排队的时候时间量为0，所以初始化时就当是0
        daiquan_time += i.endtime/i.cputime
    print(('平均周转时间：%.2f'+'  平均带权周转时间%.2f')%(Turnaround_time/len(jcbList),daiquan_time/len(jcbList)))

def HRRN(jcbList):  #响应比高者优先调度算法
    count = 0
    while jcbList[0].state == 0: #只要首部还是0就说明还有作业没执行完
        jcbList[0].state = 1
        jcbList[0].starttime = count
        count += jcbList[0].cputime
        jcbList[0].endtime = count
        jcbList[0].state = 2
        jcbList[0].outSituation_HRRN()

        jcbList.append(jcbList[0]) #将完成的作业移到序列尾部
        del jcbList[0]

        sort_HRRN(jcbList, count)

    Turnaround_time = 0
    daiquan_time = 0
    for i in jcbList :  # 计算平均周转时间
        Turnaround_time += i.endtime  # 完成时间-提交时间，因为排队的时候时间量为0，所以初始化时就当是0
        daiquan_time += i.endtime / i.cputime
    print(('平均周转时间：%.2f' + '  平均带权周转时间%.2f') % (Turnaround_time / len(jcbList), daiquan_time / len(jcbList)))


def main():
    print("现在是单道批处理系统作业调度模拟程序")
    while True :
        jcbNum = int(input("输入作业数量(4,8)："))
        print("请从以下方法中选择一种进程调度方法")
        print("（1）FCFS （2）SJF  (3)HRRN  (4)退出")
        method = int(input())
        jcbList = init(jcbNum)
        if method == 1 :
            FCFS(jcbList)
        elif method == 2 :
            SJF(jcbList)
        elif method == 3 :
            HRRN(jcbList)
        else:
            break
        print("")
        try:
            flag = int(input("输入4退出程序,或者enter进行下一次操作"))
            if flag == 4:
                break
        except:
            pass
if __name__ == '__main__':
    main()

输出

（2）多道系统作业调度模拟

import random
##这是多道处理系统作业的调度模拟，FCFS(先来先服务)算法。
class JCB :
    def __init__(self, id, cputime) :
        # id:序号  cputime:作业预计所需时间
        self.first = 0 #0代表没有进入过内存执行，进入了就加一
        self.id = id
        self.prior = 0      #可作为HRRN中需要的优先级，一开始为0，随着调度、等待而改变；
        self.cputime = cputime
        self.state = 0  # 0表示Wait 1表示Run 2表示Finish
        self.arrivetime = id
        self.starttime = 0    #进程开始运行的时间
        self.endtime = 0     #进程结束运行时间
        self.io = random.randint(1,cputime-1)
        self.restoftime = cputime

    def out_init(self):
        print(("初始化JCB序列:%-2d" + " 到达时间:%-2d"+ " 预计所需时间:%-2d" +"  io所在时间片:%-2d")%
              (self.id,self.arrivetime,self.cputime,self.io))

    def outSituation_FCFS(self) :  #输出FCFS法作业调度运行情况
        Turnaround = self.endtime - self.id
        Daiquan = Turnaround / self.cputime
        print(("FCFS： " + "作业:%-2d" + "  作业所需CPU时间:%-2d" + "  开始运行时间:%-2d"
               + "  结束运行时间:%-2d"+"  周转时间:%.2f" + "  带权周转时间:%.2f") %
              (self.id, self.cputime, self.starttime, self.endtime,Turnaround, Daiquan))


def init(num) : #创建数目确定的jcb块，按顺序放入列表中
    jcbList = []
    for i in range(num) :
        jcbList.append(JCB(i, random.randint(3, 20)))
        # 将随机产生的n个作业保存，创建id和预计CPU时间
    print("刚生成的各进程")
    for i in jcbList:  #输出最开始时进程情况
        i.out_init()
    return jcbList

def FCFS(jcbList):
    #这个系统可以同时处理3个作业，只有一个io，只要当前时间有wait的作业并且执行的作业不满3，就执行新的进程
    #如果io冲突，就让争用的作业就等待，并导入下一个进程，如果io结束，就暂停下一个进程，继续执行上一个作业
    #忽略调度程序的时间
    count = 0

    run_list = [] #len(run_list) <= 3
    while True  :
        io_flag = 0  # 为0说明没有被使用,每次也只用一个时间片，所以每次开始都是0
        if len(run_list)<3 and  jcbList[0].id <= count:
            if jcbList[0].state == 0 :
                run_list.append(jcbList[0])
                del jcbList[0]
                run_list[-1].state = 1
            if run_list[-1].first == 0 :
                run_list[-1].starttime = count
            run_list[-1].first += 1

        if len(run_list) >0 :
            for i in run_list:
                if i.io + i.starttime == count :

                    i.restoftime += 1
                    if io_flag == 0:
                        io_flag = 1
                    else:
                        i.restoftime += 1
                        i.io += 1
                    if jcbList[0].first == 0 :
                        jcbList[0].starttime = count+1
                    jcbList[0].first +=1

                    if jcbList[0].io!=1:
                        jcbList[0].restoftime -= 1
                    elif len(jcbList)>1:
                        if jcbList[1].first == 0:
                            jcbList[1].starttime = count
                        jcbList[1].first += 1
                        jcbList[1].restoftime -= 1

            for i in run_list:
                if i.restoftime == 0:
                    i.state = 2
                    i.endtime = count
                    jcbList.append(i)
                    run_list.remove(i)
                else:
                    i.restoftime -= 1
        if (len(run_list) == 0) :
            break


        count += 1
    for i in jcbList :
        i.outSituation_FCFS()

def main():
    print("现在是多道批处理系统作业调度模拟程序")
    while True :
        jcbNum = int(input("输入作业数量(4,8)："))
        print("请从以下方法中选择一种进程调度方法")
        print("（1）FCFS    (2)退出")
        method = int(input())
        jcbList = init(jcbNum)
        if method == 1 :
            FCFS(jcbList)

        elif method == 2 :
            break

        print("")
        try:
            flag = int(input("输入4退出程序,或者enter进行下一次操作"))
            if flag == 4:
                break
        except:
            pass
if __name__ == '__main__':
    main()

输出