• 操作系统实验四：进程调度

    操作系统实验四：进程调度

    写在最前面

    原文发布时间：2022-10-20 23:41:24
    质量分不高，对原文代码进行详细解读

    一、实验目的

    理解操作系统的进程调度方法，并通过一个简单的进程调度模拟程序的实现，加深对进程调度算法，进程切换的理解。

    二、实验内容

    1、采用动态优先数的方法，编写一进程调度程序模拟程序。模拟程序只进行相应的调度模拟操作，不需要实际程序。
    具体要求如下：
    (1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：

    在这里插入图片描述

    (2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。
    (3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程，用指针指出队列的连接情况。
    (4) 处理器调度总是选队首进程运行。采用动态改变优先数的办法，进程每运行一次优先数就减“1”。由于本实习是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行{优先数-1；要求运行时间-1}，来模拟进程的一次运行。
    提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。在这里省去了这些工作。
    (5) 进程运行一次后，若要求运行时间?0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。
    (6) 若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。
    (7) 在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。
    (8) 为五个进程任意确定一组“优先数”和“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

    三、实验要求

    1、 写出程序，并调试程序，要给出测试数据和实验结果。
    2、 整理上机步骤，总结经验和体会。
    3、 完成实验报告和上交程序。

    四、实验代码

    import random

class PCB :
    def __init__(self, id, prior, cputime) :
        # id:序号 prior优先级 cputime:进程所需时间
        self.id = id
        self.prior = prior      #这是初始值的优先级，不会再变了，可以看做静态优先级
        self.dy_prior = prior   #动态优先级，每执行一次要减一
        self.cputime = cputime
        self.runtime = 0  # 进程已运行的时间，就是流程图中已占用CPU时间片数，每执行一次-1
        self.restoftime = cputime   # 还需要的运行的时间，
        self.state = 0  # 0表示ready 1表示running 2表示finish
        self.starttime = 0    #进程开始运行的时间
        self.endtime = 0     #进程结束运行时间

    def outSituation_dy(self) :  #输出动态优先级法进程运行情况
        state_temp = ''
        if self.state == 0:
            state_temp = 'ready'
        elif self.state == 1:
            state_temp = 'running'
        elif self.state == 2 :
            state_temp = 'finish'
        print(("进程:" + str(self.id) + '\t' +"动态优先级:%-3d" + " 当前状态:%-7s" + "  进程所需CPU时间:%-2d" +
               "  还需时间:" + str(self.restoftime))%(self.dy_prior,state_temp,self.cputime))

    def outSituation_rr(self) :  #输出rr法进程运行情况
        state_temp = ''
        if self.state == 0:
            state_temp = 'ready'
        elif self.state == 1:
            state_temp = 'running'
        elif self.state == 2 :
            state_temp = 'finish'
        print(("进程:" + str(self.id) + " 当前状态:%-7s" + "  进程所需CPU时间:%-2d" +
               "  还需时间:" + str(self.restoftime))%(state_temp,self.cputime))

    def outall_dy(self) :  #输出动态优先级法进程运行总体情况
        state_temp = ''
        if self.state == 0:
            state_temp = 'ready'
        elif self.state == 1:
            state_temp = 'running'
        elif self.state == 2 :
            state_temp = 'finish'
        print(("进程:" + str(self.id) + '\t' +"静态优先级:%-3d" + " 当前状态:%-7s" + "进程所需CPU时间:%-2d" + " 开始运行时间：%-2d" +
               " 结束运行时间：%-3d"+" 还需时间:" + str(self.restoftime))%(self.prior,state_temp,self.cputime,self.starttime,self.endtime,))

    def outall_rr(self) :  #输出rr法进程运行总体情况
        state_temp = ''
        if self.state == 0:
            state_temp = 'ready'
        elif self.state == 1:
            state_temp = 'running'
        elif self.state == 2 :
            state_temp = 'finish'
        print(("进程:" + str(self.id) + " 当前状态:%-7s" + "进程所需CPU时间:%-2d" + " 开始运行时间：%-2d" +
               " 结束运行时间：%-3d"+" 还需时间:" + str(self.restoftime))%(state_temp,self.cputime,self.starttime,self.endtime,))

def init(num) :
    pcbList = []
    for i in range(num) :
        pcbList.append(PCB(i, random.randint(1, 9), random.randint(1, 20)))
        # 将随机产生的n个进程保存，里面分别是进程id,优先级，CPU时间
    print("刚生成的各进程")
    for i in pcbList:  #输出最开始时进程情况
        i.outSituation_dy()
    print('\n')
    return pcbList

def sort_dy_pcblist(pcbList): #按优先级将进程排序，[0:]优先级依次减小
    for i in range(1,len(pcbList)): #冒泡排序
        for j in range(0,len(pcbList)-1):
            if pcbList[i].dy_prior > pcbList[j].dy_prior:
                pcbList[i], pcbList[j] = pcbList[j], pcbList[i]
    for i in range(len(pcbList)-1):  #相同优先级的，id小的排在前面
        if pcbList[i].dy_prior == pcbList[i+1].dy_prior:
            if pcbList[i].id > pcbList[i+1].id:
                pcbList[i],pcbList[i + 1] = pcbList[i + 1], pcbList[i]
    if pcbList[0].state == 2 :  #保证首位不是finish 如果是，和后面第一个ready交换
        for i in range(1,len(pcbList)):
            if pcbList[i].state == 0 :
                pcbList[i],pcbList[0] = pcbList[0],pcbList[i]
                break
    return pcbList

def sort_rr_pcblist(pcbList):  #将进程插到队列尾
    pcbList.append(pcbList[0])
    del pcbList[0]
    if pcbList[0].state == 2 :  #保证首位不是finish 如果是，和后面第一个ready交换
        for i in range(1,len(pcbList)):
            if pcbList[i].state == 0 :
                pcbList[i],pcbList[0] = pcbList[0],pcbList[i]
                break
    return pcbList

def dy_prior_method(pcbList) :  #动态优先级法
    count = 0
    while pcbList[0].state == 0:  #只要首进程状态为ready，就说明还有进程未执行
        print("这是第%d次时间片"%count)
        if pcbList[0].dy_prior == pcbList[0].prior :
            pcbList[0].starttime = count
        pcbList[0].state = 1      #状态变更为running
        pcbList[0].runtime += 1
        pcbList[0].dy_prior -= 3
        pcbList[0].restoftime -= 1
        for i in pcbList :  # 输出进程情况
            i.outSituation_dy()
        if pcbList[0].restoftime == 0:
            pcbList[0].state = 2
            pcbList[0].endtime = count
        else :
            pcbList[0].state = 0
        sort_dy_pcblist(pcbList)
        count += 1

    # 显示进程运行总体情况
    print("                 动态优先级         总 体 情 况                   ")
    # 输出完成时进程情况
    Turnaround_time = 0   #总周转时间周转
    daiquan_time = 0      #总带权周转时间
    for j in range(len(pcbList)): #按id顺序输出
        for i in pcbList:
            if i.id == j :
                i.outall_dy()
    for i in pcbList :  # 计算平均周转时间
        Turnaround_time += i.endtime - i.starttime+1   #时间从0开始，两个相减就少了一段时间片
        daiquan_time += (i.endtime-i.starttime+1)/i.cputime
    print(('平均周转时间：%.2f'+'  平均带权周转时间%.2f')%(Turnaround_time/len(pcbList),daiquan_time/len(pcbList)))
    #周转时间就是就是执行完成的时间-开始执行的时间
    #带权周转时间就是  周转时间/所需时间


#轮转法比动态优先级简单，直接对着流程图抄上一个函数就好了。
def rr_method(pcbList) :   #轮转法
    rr_time = random.randint(1,5) #随机产生一个时间片  流程图害人
    count = 0
    time = 0  #每个进程已经占用的时间片，time<=rr_time
    while pcbList[0].state == 0 :
        print("这是第%d次时间片"%count)
        time += 1
        if pcbList[0].dy_prior == pcbList[0].prior :
            #首次执行就改变动态优先级，这个参数在这里没啥用，不如废物利用
            pcbList[0].starttime = count
            pcbList[0].dy_prior = 21 #要保证比随机数大
        pcbList[0].state = 1      #状态变更为running
        pcbList[0].runtime +=  1
        pcbList[0].restoftime -=  1
        for i in pcbList :  # 输出进程情况
            i.outSituation_rr()
        if pcbList[0].restoftime == 0:
            pcbList[0].state = 2
            pcbList[0].endtime = count
            sort_rr_pcblist(pcbList)
            time = 0
        else :
            pcbList[0].state = 0
            if time == rr_time :
                time = 0
                sort_rr_pcblist(pcbList)
        count += 1

    #显示进程运行总体情况
    print("                 轮转法         总 体 情 况                   ")
    # 输出完成时进程情况
    print("轮转时间片 q = "+str(rr_time))
    Turnaround_time = 0  # 总周转时间周转
    daiquan_time = 0  # 总带权周转时间
    for j in range(len(pcbList)) : #按id顺序输出
        for i in pcbList :
            if i.id == j :
                i.outall_rr()
    for i in pcbList :  # 计算平均周转时间
        Turnaround_time += i.endtime - i.starttime + 1  # 时间从0开始，两个相减就少了一段时间片
        daiquan_time += (i.endtime - i.starttime + 1) / i.cputime
    print(('平均周转时间：%.2f' + '  平均带权周转时间%.2f') % (Turnaround_time / len(pcbList), daiquan_time / len(pcbList)))

def main() :
    pcbNum = int(input("输入进程数量(4,8)："))
    print("请从以下方法中选择一种进程调度方法")
    print("（1）动态优先级法 （2）轮转法")
    method = int(input())
    pcbList = init(pcbNum)
    if method == 1 :
        dy_prior_method(pcbList)
    else :
        rr_method(pcbList)

if __name__ == '__main__' :
    main()


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191

    实验结果

    没找到原来的实验报告

    动态优先级法
    在这里插入图片描述
    在这里插入图片描述

    轮转法
    在这里插入图片描述
    在这里插入图片描述

    代码解读

    init函数

    def init(num) :
    pcbList = []
    for i in range(num) :
        pcbList.append(PCB(i, random.randint(1, 9), random.randint(1, 20)))
        # 将随机产生的n个进程保存，里面分别是进程id,优先级，CPU时间
    print("刚生成的各进程")
    for i in pcbList:  #输出最开始时进程情况
        i.outSituation_dy()
    print('\n')
    return pcbList

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    它接受一个名为num的参数作为输入。以下是代码的详细解读：

    1. pcbList = []：创建一个空的列表，用于存储进程控制块（PCB）对象。

    2. for i in range(num):：使用for循环，迭代num次，这个循环用于生成多个进程。

    3. pcbList.append(PCB(i, random.randint(1, 9), random.randint(1, 20)))：在循环中，创建一个新的PCB对象，并将其添加到pcbList列表中。这个PCB对象具有以下属性：

      • 进程ID：i，从0到num-1的循环变量。
      • 优先级：通过random.randint(1, 9)随机生成一个介于1和9之间的整数。
      • CPU时间：通过random.randint(1, 20)随机生成一个介于1和20之间的整数。

    4. print("刚生成的各进程")：输出一行文本，表示下面输出的是刚生成的各个进程的情况。

    5. for i in pcbList:：使用for循环，遍历pcbList列表中的每个PCB对象。

    6. i.outSituation_dy()：调用PCB对象的outSituation_dy()方法，该方法用于输出当前PCB对象的信息，包括进程ID、优先级和CPU时间。

    7. print('\n')：输出一个空行，用于在不同进程信息之间进行分隔。

    8. return pcbList：返回填充了PCB对象的列表pcbList。

    综上所述，这个init函数的作用是生成一些随机的进程，每个进程都有一个唯一的ID、随机的优先级和CPU时间。这些进程的信息会被输出到控制台。这段代码似乎是一个模拟操作系统中进程管理的初始阶段。在生成这些随机进程后，您可以进一步模拟它们的执行和调度。

    sort_dy_pcblist函数

    def sort_dy_pcblist(pcbList): #按优先级将进程排序，[0:]优先级依次减小
    for i in range(1,len(pcbList)): #冒泡排序
        for j in range(0,len(pcbList)-1):
            if pcbList[i].dy_prior > pcbList[j].dy_prior:
                pcbList[i], pcbList[j] = pcbList[j], pcbList[i]
    for i in range(len(pcbList)-1):  #相同优先级的，id小的排在前面
        if pcbList[i].dy_prior == pcbList[i+1].dy_prior:
            if pcbList[i].id > pcbList[i+1].id:
                pcbList[i],pcbList[i + 1] = pcbList[i + 1], pcbList[i]
    if pcbList[0].state == 2 :  #保证首位不是finish 如果是，和后面第一个ready交换
        for i in range(1,len(pcbList)):
            if pcbList[i].state == 0 :
                pcbList[i],pcbList[0] = pcbList[0],pcbList[i]
                break
    return pcbList

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    这段代码定义了一个名为sort_dy_pcblist的函数，其目的是按照进程的优先级对进程列表进行排序。下面是代码的详细解读：

    1. def sort_dy_pcblist(pcbList):：这是一个接受一个名为pcbList的参数的函数，其中pcbList是一个包含多个进程控制块（PCB）对象的列表。

    2. for i in range(1, len(pcbList)): for j in range(0, len(pcbList)-1):：这是一个冒泡排序算法的嵌套循环，用于比较并按照优先级对pcbList中的PCB对象进行排序。外层循环从第二个元素开始，内层循环从第一个元素开始。

    3. if pcbList[i].dy_prior > pcbList[j].dy_prior:：在内层循环中，比较两个PCB对象的优先级属性(dy_prior)。如果pcbList[i]的优先级较高，就执行下面的交换操作。

    4. pcbList[i], pcbList[j] = pcbList[j], pcbList[i]：如果pcbList[i]的优先级较高，就交换pcbList[i]和pcbList[j]的位置，以便较高优先级的PCB对象排在前面。

    5. for i in range(len(pcbList)-1):：这是一个遍历pcbList中的PCB对象的循环，用于处理具有相同优先级的情况。

    6. if pcbList[i].dy_prior == pcbList[i+1].dy_prior:：检查相邻的两个PCB对象是否具有相同的优先级。

    7. if pcbList[i].id > pcbList[i+1].id:：如果它们的优先级相同，就比较它们的进程ID(id)，如果前一个PCB的ID较大（通常意味着较早创建），则执行下面的交换操作。

    8. pcbList[i], pcbList[i+1] = pcbList[i+1], pcbList[i]：交换相邻的两个PCB对象，以便ID较小的PCB排在前面，保持相同优先级的PCB有序。

    9. if pcbList[0].state == 2:：检查第一个PCB对象的状态是否为2，通常代表“finish”。

    10. for i in range(1, len(pcbList)):：如果第一个PCB对象的状态是“finish”，则从第二个PCB对象开始遍历pcbList，以找到一个状态为0（通常代表“ready”）的PCB对象。

    11. pcbList[i], pcbList[0] = pcbList[0], pcbList[i]：如果找到了符合条件的PCB对象，将其与第一个PCB对象交换位置，以确保第一个PCB对象不是“finish”。

    12. return pcbList：返回排序后的pcbList，其中PCB对象按照优先级递减排列，对于相同优先级的PCB对象，按照ID递增排列，同时确保第一个PCB对象不是“finish”状态。

    综上所述，这个函数的主要功能是对PCB对象列表按照优先级和ID进行排序，以便进行进程调度和执行。

    dy_prior_method函数：动态优先级法

    def dy_prior_method(pcbList) :  #动态优先级法
    count = 0
    while pcbList[0].state == 0:  #只要首进程状态为ready，就说明还有进程未执行
        print("这是第%d次时间片"%count)
        if pcbList[0].dy_prior == pcbList[0].prior :
            pcbList[0].starttime = count
        pcbList[0].state = 1      #状态变更为running
        pcbList[0].runtime += 1
        pcbList[0].dy_prior -= 3
        pcbList[0].restoftime -= 1
        for i in pcbList :  # 输出进程情况
            i.outSituation_dy()
        if pcbList[0].restoftime == 0:
            pcbList[0].state = 2
            pcbList[0].endtime = count
        else :
            pcbList[0].state = 0
        sort_dy_pcblist(pcbList)
        count += 1

    # 显示进程运行总体情况
    print("                 动态优先级         总 体 情 况                   ")
    # 输出完成时进程情况
    Turnaround_time = 0   #总周转时间周转
    daiquan_time = 0      #总带权周转时间
    for j in range(len(pcbList)): #按id顺序输出
        for i in pcbList:
            if i.id == j :
                i.outall_dy()
    for i in pcbList :  # 计算平均周转时间
        Turnaround_time += i.endtime - i.starttime+1   #时间从0开始，两个相减就少了一段时间片
        daiquan_time += (i.endtime-i.starttime+1)/i.cputime
    print(('平均周转时间：%.2f'+'  平均带权周转时间%.2f')%(Turnaround_time/len(pcbList),daiquan_time/len(pcbList)))
    #周转时间就是就是执行完成的时间-开始执行的时间
    #带权周转时间就是  周转时间/所需时间

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    这段代码定义了一个名为dy_prior_method的函数，它实现了动态优先级法的进程调度算法。以下是代码的详细解读：

    1. def dy_prior_method(pcbList):：这是一个接受一个名为pcbList的参数的函数，其中pcbList是包含多个进程控制块（PCB）对象的列表。

    2. count = 0：用于追踪时间片的计数器。

    3. while pcbList[0].state == 0:：这是一个while循环，只要第一个PCB对象的状态为0（通常代表"ready"），就说明还有进程未执行。在这种情况下，会一直执行下面的代码块。

    4. print("这是第%d次时间片"%count)：输出当前时间片的计数。

    5. if pcbList[0].dy_prior == pcbList[0].prior:：检查第一个PCB对象的动态优先级是否等于原始优先级。如果相等，就将该时间片标记为进程的开始执行时间。

    6. pcbList[0].state = 1：将第一个PCB对象的状态从"ready"（0）更改为"running"（1）。

    7. pcbList[0].runtime += 1：增加第一个PCB对象的运行时间。

    8. pcbList[0].dy_prior -= 3：降低第一个PCB对象的动态优先级。

    9. pcbList[0].restoftime -= 1：减少第一个PCB对象的剩余运行时间。

    10. for i in pcbList:：遍历pcbList中的所有PCB对象。

    11. i.outSituation_dy()：输出每个PCB对象的当前情况，包括ID、状态、动态优先级等。

    12. if pcbList[0].restoftime == 0:：检查第一个PCB对象的剩余运行时间是否为0，如果是，说明进程已经执行完毕。

    13. pcbList[0].state = 2：将第一个PCB对象的状态设置为2（通常代表"finish"）。

    14. pcbList[0].endtime = count：记录第一个PCB对象的结束执行时间。

    15. else:：如果剩余运行时间不为0，说明进程还未执行完毕。

    16. pcbList[0].state = 0：将第一个PCB对象的状态重新设置为0（“ready”）。

    17. sort_dy_pcblist(pcbList)：调用名为sort_dy_pcblist的函数对pcbList进行排序，以便按照动态优先级和ID重新排列。

    18. count += 1：增加时间片的计数。

    19. 在while循环之外，代码会输出总体情况，包括每个进程的信息、平均周转时间和平均带权周转时间。

    20. for j in range(len(pcbList)):：遍历所有的进程ID，用于按ID顺序输出进程信息。

    21. for i in pcbList:：再次遍历pcbList中的所有PCB对象。

    22. if i.id == j:：检查当前PCB对象的ID是否与迭代的ID相匹配。

    23. i.outall_dy()：输出匹配的PCB对象的所有信息，包括ID、状态、起始时间、结束时间等。

    24. Turnaround_time 和 daiquan_time 分别用于累积总周转时间和总带权周转时间。

    25. Turnaround_time += i.endtime - i.starttime + 1：计算总周转时间，加1是因为时间从0开始，两个时间相减会少一次时间片。

    26. daiquan_time += (i.endtime - i.starttime + 1) / i.cputime：计算总带权周转时间，它是总周转时间除以CPU时间。

    27. 最后，计算并输出平均周转时间和平均带权周转时间。

    综上所述，这个函数实现了动态优先级法的进程调度算法，对进程列表进行动态调度，记录进程的运行情况，并输出总体情况，包括平均周转时间和带权周转时间。

    rr_method函数：轮转法

    #轮转法比动态优先级简单，直接对着流程图抄上一个函数就好了。
def rr_method(pcbList) :   #轮转法
    rr_time = random.randint(1,5) #随机产生一个时间片  流程图害人
    count = 0
    time = 0  #每个进程已经占用的时间片，time<=rr_time
    while pcbList[0].state == 0 :
        print("这是第%d次时间片"%count)
        time += 1
        if pcbList[0].dy_prior == pcbList[0].prior :
            #首次执行就改变动态优先级，这个参数在这里没啥用，不如废物利用
            pcbList[0].starttime = count
            pcbList[0].dy_prior = 21 #要保证比随机数大
        pcbList[0].state = 1      #状态变更为running
        pcbList[0].runtime +=  1
        pcbList[0].restoftime -=  1
        for i in pcbList :  # 输出进程情况
            i.outSituation_rr()
        if pcbList[0].restoftime == 0:
            pcbList[0].state = 2
            pcbList[0].endtime = count
            sort_rr_pcblist(pcbList)
            time = 0
        else :
            pcbList[0].state = 0
            if time == rr_time :
                time = 0
                sort_rr_pcblist(pcbList)
        count += 1

    #显示进程运行总体情况
    print("                 轮转法         总 体 情 况                   ")
    # 输出完成时进程情况
    print("轮转时间片 q = "+str(rr_time))
    Turnaround_time = 0  # 总周转时间周转
    daiquan_time = 0  # 总带权周转时间
    for j in range(len(pcbList)) : #按id顺序输出
        for i in pcbList :
            if i.id == j :
                i.outall_rr()
    for i in pcbList :  # 计算平均周转时间
        Turnaround_time += i.endtime - i.starttime + 1  # 时间从0开始，两个相减就少了一段时间片
        daiquan_time += (i.endtime - i.starttime + 1) / i.cputime
    print(('平均周转时间：%.2f' + '  平均带权周转时间%.2f') % (Turnaround_time / len(pcbList), daiquan_time / len(pcbList)))

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    这段代码定义了一个名为dy_prior_method的函数，它实现了动态优先级法的进程调度算法。以下是代码的详细解读：

    1. def dy_prior_method(pcbList):：这是一个接受一个名为pcbList的参数的函数，其中pcbList是包含多个进程控制块（PCB）对象的列表。

    2. count = 0：用于追踪时间片的计数器。

    3. while pcbList[0].state == 0:：这是一个while循环，只要第一个PCB对象的状态为0（通常代表"ready"），就说明还有进程未执行。在这种情况下，会一直执行下面的代码块。

    4. print("这是第%d次时间片"%count)：输出当前时间片的计数。

    5. if pcbList[0].dy_prior == pcbList[0].prior:：检查第一个PCB对象的动态优先级是否等于原始优先级。如果相等，就将该时间片标记为进程的开始执行时间。

    6. pcbList[0].state = 1：将第一个PCB对象的状态从"ready"（0）更改为"running"（1）。

    7. pcbList[0].runtime += 1：增加第一个PCB对象的运行时间。

    8. pcbList[0].dy_prior -= 3：降低第一个PCB对象的动态优先级。

    9. pcbList[0].restoftime -= 1：减少第一个PCB对象的剩余运行时间。

    10. for i in pcbList:：遍历pcbList中的所有PCB对象。

    11. i.outSituation_dy()：输出每个PCB对象的当前情况，包括ID、状态、动态优先级等。

    12. if pcbList[0].restoftime == 0:：检查第一个PCB对象的剩余运行时间是否为0，如果是，说明进程已经执行完毕。

    13. pcbList[0].state = 2：将第一个PCB对象的状态设置为2（通常代表"finish"）。

    14. pcbList[0].endtime = count：记录第一个PCB对象的结束执行时间。

    15. else:：如果剩余运行时间不为0，说明进程还未执行完毕。

    16. pcbList[0].state = 0：将第一个PCB对象的状态重新设置为0（“ready”）。

    17. sort_dy_pcblist(pcbList)：调用名为sort_dy_pcblist的函数对pcbList进行排序，以便按照动态优先级和ID重新排列。

    18. count += 1：增加时间片的计数。

    19. 在while循环之外，代码会输出总体情况，包括每个进程的信息、平均周转时间和平均带权周转时间。

    20. for j in range(len(pcbList)):：遍历所有的进程ID，用于按ID顺序输出进程信息。

    21. for i in pcbList:：再次遍历pcbList中的所有PCB对象。

    22. if i.id == j:：检查当前PCB对象的ID是否与迭代的ID相匹配。

    23. i.outall_dy()：输出匹配的PCB对象的所有信息，包括ID、状态、起始时间、结束时间等。

    24. Turnaround_time 和 daiquan_time 分别用于累积总周转时间和总带权周转时间。

    25. Turnaround_time += i.endtime - i.starttime + 1：计算总周转时间，加1是因为时间从0开始，两个时间相减会少一次时间片。

    26. daiquan_time += (i.endtime - i.starttime + 1) / i.cputime：计算总带权周转时间，它是总周转时间除以CPU时间。

    27. 最后，计算并输出平均周转时间和平均带权周转时间。

    综上所述，这个函数实现了动态优先级法的进程调度算法，对进程列表进行动态调度，记录进程的运行情况，并输出总体情况，包括平均周转时间和带权周转时间。

  • 相关阅读:
    【CSP-J/S初赛知识点整理】
    激光雕刻机的雕刻操作
    《论文阅读：Dataset Condensation with Distribution Matching》
    springboot生成图片并在图片上添加字体进行换行
    可以实现psd转png转换器有哪些？这些工具能让你轻松转换图片格式
    大厂秋招真题【BFS+DP】华为20230921秋招T3-PCB印刷电路板布线【欧弟算法】全网最全大厂秋招题解
    Flex布局—固定定位+流式布局—主轴对齐—侧轴对齐—伸缩比
    C Primer Plus(6) 中文版 第6章 C控制语句：循环 6.2 while语句
    JVM虚拟机：对象在内存中的存储布局
    【Spring Security 系列】（一）理论篇
  • 原文地址：https://blog.csdn.net/wtyuong/article/details/127437390