实验内容

模拟实现FCFS/SJF调度。

设置作业体：作业名，作业的到达时间，服务时间，作业状态（W——等待,R——运行,F——完成），作业间的链接指针；

作业初始化：由用户输入作业名、服务时间、到达时间进行初始化，同时，初始化作业的状态为W。

显示函数：在作业调度前、调度中和调度后进行显示。

排序函数：对等待状态的作业按照调度算法排序（不同的调度算法排序方式不同），注意考虑到达时间。

调度函数：每次从等待队列队首调度已到达的适合的作业执行，状态变化。当服务结束时，状态变为F。

删除函数：撤销状态为F的作业。

实验要求

（1）测试数据可以随即输入或从文件中读入；

（2）必须要考虑到作业的到达时间；

（3）最终能够计算每一个作业的周转时间、带权周转时间。

pcb=[]
n=int(input("请输入你的进程数："))
def inPcb():
    i=0
    while(i<n):
        print("********************************************") 
        pName = input("请输入第 %d 个进程名：" % (i+1))
        print("请输入到达时间和服务时间:",end="")
        arriveTime,serviceTime=map(int,input().split())
        pcb.append([pName,arriveTime,serviceTime,0,0,0,0,])
        i=i+1
#文件输入数据
def fileinPcb():
    filename=input("请输入文件名：")
    infile=open(filename,"r")
    data=infile.read()
    print("文件内容：")
    print(data)
    data=data.split()
    k=0
    while(k<n):
        pcb.append([0,0,0,0,0,0,0,])
        k=k+1
    s=0
    for i in range(n):
        for j in range(3):
            pcb[i][j]=data[s]
            s=s+1
#先来先调度算法
def FCFS():
    #对列表按照到达时间进行升序排序  x:x[1]为依照到达时间进行排序
    pcb.sort(key = lambda x:x[1], reverse = False )
    #计算开始、完成时间
    for i in range(n):
        if(i == 0):
            startTime = int(pcb[i][1])
            pcb[i][3] = startTime
            pcb[i][4] = startTime + int(pcb[i][2])
        elif(i > 0 and  int(pcb[i - 1][4]) < int(pcb[i][1])):
            startTime = int(pcb[i][1])
            pcb[i][3] = startTime
            pcb[i][4] = startTime + int(pcb[i][2])
        else:
            startTime = int(pcb[i - 1][4])
            pcb[i][3] = startTime
            pcb[i][4] = startTime + int(pcb[i][2])
        i += 1
    #计算周转、带权周转时间
    for i in range(n):
        pcb[i][5] = float(pcb[i][4] - int(pcb[i][1]))
        pcb[i][6] = float(pcb[i][5] / int(pcb[i][2]))
        i += 1
    #计算平均周转时间和平均带权周转时间
    SzzTime = 0
    SdqzzTime = 0
    for i in range(n):
        SzzTime = float(SzzTime + float(pcb[i][5]))
        SdqzzTime = float(SdqzzTime + float(pcb[i][6]))
    AzzTime = float(SzzTime / n)
    AdqzzTime = float(SdqzzTime / n)
    #输出结果，按照开始时间进行排序
    pcb.sort(key = lambda x:x[3], reverse = False)
    print("FCFS运行结果:")
    print("进程   到达时间  服务时间 开始时间  完成时间  周转时间  带权周转时间")
    for i  in range(n):
        print("%s%10.1f%10.1f%10.1f%10.1f%10.1f%10.2f"%(pcb[i][0],float(pcb[i][1]),float(pcb[i][2]),float(pcb[i][3]),float(pcb[i][4]),float(pcb[i][5]),float(pcb[i][6])))
        i += 1
    print("本次调度的平均周转时间为： %.2f" % float(AzzTime))
    print("本次调度的平均带权周转时间为： %.2f" % float(AdqzzTime))
#短作业优先调度算法
def SJF():
    sjf_pcb = pcb
    i = 1
    k = 0
    # 对列表按照到达时间进行升序排序  x:x[1]为依照到达时间进行排序
    sjf_pcb.sort(key = lambda x: x[1], reverse = False)
    #定义列表的第一项内容
    startTime0 = int(sjf_pcb[0][1])
    pcb[0][3] = startTime0
    pcb[0][4] = startTime0 + int(sjf_pcb[0][2])
    sjf_pcb[0][5] = int(sjf_pcb[0][4]) - int(sjf_pcb[0][1])
    sjf_pcb[0][6] = float(sjf_pcb[0][5]) / int(sjf_pcb[0][2])
    # 对后背队列按照服务时间排序
    temp_pcb = sjf_pcb[1:len(sjf_pcb)]   #切片 临时存放后备队列  len(sjf_pcb)获取长度
    temp_pcb.sort(key=lambda x: x[2], reverse=False)
    sjf_pcb[1:len(sjf_pcb)] = temp_pcb
    #进行计算 用K值避免对最后一个进程的两次计算
    while(i < n):
        h = 1
        # 比较到达时间和前一者的完成时间，判断是否需要进行重新排序
        while(int(sjf_pcb[i][1]) >= int(sjf_pcb[i - 1][4])):
            if(i == n-1):    #当最后一个进程的到达时间大于前一个进程的完成时间
                startTime = sjf_pcb[i][1]
                sjf_pcb[i][3] = startTime
                sjf_pcb[i][4] = startTime + int(sjf_pcb[i][2])
                sjf_pcb[i][5] = int(sjf_pcb[i][4]) - int(sjf_pcb[i][1])
                sjf_pcb[i][6] = float(sjf_pcb[i][5]) / int(sjf_pcb[i][2])
                k = 1      #设置参数对比，避免一重循环之后再对末尾进程重新计算
                break
            else:      #对进程顺序进行调换
                temp_sjf_pcb = sjf_pcb[i]
                sjf_pcb[i] = sjf_pcb[i + h]
                sjf_pcb[i + h] = temp_sjf_pcb
                h += 1
                #如果后面的所有进程的到达时间都大于第 i 个进程的完成时间
                #则重新将i之后的进程按照服务时间排序，直接对其进行计算，同时i += 1,直接开始后面的计算              
                if( h >= n - i - 1):
                    temp_pcb2 = sjf_pcb[i:len(sjf_pcb)]
                    temp_pcb2.sort(key=lambda x: x[1], reverse=False)   # 后续队列重新按照到达时间顺序进行排序
                    sjf_pcb[i:len(sjf_pcb)] = temp_pcb2
                    sjf_pcb[i][3] = int(sjf_pcb[i][1])
                    sjf_pcb[i][4] = int(sjf_pcb[i][1]) + int(sjf_pcb[i][2])
                    sjf_pcb[i][5] = int(sjf_pcb[i][4]) - int(sjf_pcb[i][1])
                    sjf_pcb[i][6] = float(sjf_pcb[i][5]) / int(sjf_pcb[i][2])
                    temp_pcb2 = sjf_pcb[i + 1:len(sjf_pcb)]
                    temp_pcb2.sort(key=lambda x: x[2], reverse=False)  # 重新按照服务时间排序
                    sjf_pcb[i + 1:len(sjf_pcb)] = temp_pcb2
                    h = 1
                    i += 1
                else:
                 continue
        if(k == 1):
            break
        else:
            startTime = sjf_pcb[i - 1][4]
            sjf_pcb[i][3] = startTime
            sjf_pcb[i][4] = startTime + int(sjf_pcb[i][2])
            sjf_pcb[i][5] = int(sjf_pcb[i][4]) - int(sjf_pcb[i][1])
            sjf_pcb[i][6] = float(sjf_pcb[i][5]) / int(sjf_pcb[i][2])
            i += 1
    # 计算平均周转时间和平均带权周转时间
    SzzTime = 0
    SdqzzTime = 0
    for i in range(n):
        SzzTime = float(SzzTime + float(pcb[i][5]))
        SdqzzTime = float(SdqzzTime + float(pcb[i][6]))
        AzzTime = float(SzzTime / n)
        AdqzzTime = float(SdqzzTime / n)
    # 输出结果，按照开始时间进行排序
    sjf_pcb.sort(key=lambda x: x[3], reverse=False)
    print("SJF运行结果:")
    print("进程   到达时间  服务时间 开始时间  完成时间  周转时间  带权周转时间")
    for i  in range(n):
        print("%s%10.1f%10.1f%10.1f%10.1f%10.1f%10.2f"%(pcb[i][0],float(pcb[i][1]),float(pcb[i][2]),float(pcb[i][3]),float(pcb[i][4]),float(pcb[i][5]),float(pcb[i][6])))
        i += 1
    print("本次调度的平均周转时间为： %.2f" % float(AzzTime))
    print("本次调度的平均带权周转时间为： %.2f" % float(AdqzzTime))
 if __name__ == '__main__':
    print("提供两种数据输入方式：1.终端输入  2.文件输入")
    option1=int(input("请选择输入方式："))
    if(option1==1):
        inPcb()
    elif(option1==2):
        fileinPcb()
    else:
        print("输入错误，请关闭，重新运行程序")
    print()
    print("算法一：先来先服务算法FCFS")
    print("算法二：短作业优先算法SJF")
    m = 1
    while(m == 1):
        option = int(input("请输入你要选择的算法(输入1，2进行选择，其他退出):"))
        if(option == 1):
            FCFS()
        elif(option == 2):
            SJF()
        else:
            print("退出计算")
            m = 0