python实现操作系统FCFS和SJF调度算法

最新推荐文章于 2023-12-04 11:08:10 发布
最新推荐文章于 2023-12-04 11:08:10 发布
阅读量2.3k 收藏 33
点赞数 3
分类专栏： Python 操作系统 文章标签： python 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42437183/article/details/105639189
版权
实验内容

模拟实现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
苦笑的背后
关注
  • 3
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
作业调度算法
10-26
作业调度，先来先服务和高响应比优先两个算法，c和c++实现， 从文件中读取数据.....
Python实战——实现进程调度算法：先来先服务（FCFS）、短作业优先（SJF）和动态最高优先数优先（HRRN）
qq_44883083的博客
06-24 1万+
Python实战——实现进程调度算法：FCFS、SJF和HRRN 实验要求 进程调度算法：采用先来先服务、短作业、动态最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）。 每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息： 进程名—进程标示数 ID 优先数 PRIORITY 优先数越大优先权越高（仅HRRN） 到达时间—进程的到达时间为进程输入的时间。、 进程还需...
Python-FCFS调度算法
admin_cola的博客
04-19 2911
操作系统作业:实现FCFS调度算法并用文件的方式读取进程信息和输出进程执行顺序，因为不要求使用的语言，所以就用我最喜欢的Python来写： 算法比较简单，以下是源码： import ast f = open("C:\\ff.txt","r") ff = f.read() str1 = ff.replace("\n"," ") list = str1.split(" ") #print(str)
操作系统实验一 短作业优先调度算法
名字太长容易被发现并打死
05-10 2598
一、实验目的： 了解并掌握作业调度的功能，熟悉并掌握各种作业调度算法。 二、实验内容： 模拟实现FCFS/SJF调度。 设置作业体：作业名，作业的到达时间，服务时间，作业状态（W——等待,R——运行,F——完成），作业间的链接指针； 作业初始化：由用户输入作业名、服务时间、到达时间进行初始化，同时，初始化作业的状态为W。 显示函数：在作业调度前、调度中和调度后进行显示。 排序函数：对等待状态的作业按照调度算法排序（不同的调度算法排序方式不同），注意考虑到达时间。 调度函数：每次从等待队列队首调度已到达的适合
python实现FCFS算法
最新发布
Zc2787449041的博客
12-04 463
【代码】python实现FCFS算法。
操作系统——sjf算法python实现
Growing_hacker的博客
04-02 2286
python源码： 代码： # --*-- coding:utf-8 --*-- # python3.5 import time pcb = [] # 列表保存进程 # 输入函数 def InPcb(): # n 计数读取的行数 n = 0 print("读取的文本内容为......") with open("pcb.txt") a...
操作系统 实验1【短作业优先调度算法（C++代码实现——FCFS\SJF\HRRN）】
热门推荐
upward
04-28 1万+
先来先服务（FCFS） 短作业（SJF） 高响应比优先（HRRN）
操作系统第一次实验-短作业优先调度算法
qq_49383677的博客
06-11 3647
目的：了解并掌握作业调度的功能，熟悉并掌握各种作业调度算法。 任务：模拟实现先来先服务或者短作业优先调度算法。模拟实现SJF调度。 设置作业体：作业名，作业的到达时间，服务时间，作业状态（W——等待,R——运行,F——完成），作业间的链接指针； 作业初始化：由用户输入作业名、服务时间、到达时间进行初始化，同时，初始化作业的状态为W。 显示函数：在作业调度前、调度中和调度后进行显示。 排序函数：对等待状态的作业按照调度算法排序（不同的调度算法排序方式不同），注意考虑到达时间。 调度函数：每次从等待队列队首调度
操作系统_进程调度算法（FCFS）
weixin_45913784的博客
03-27 2909
操作系统_处理器管理_先到先服务算法： 问题描述： 输入N(N>0)个作业，输入每个作业的名字，到达时间，服务时间，按照先来先服务算法，计算每个作业的完成时间，周转时间，带权周转时间（保留2位小数）。 输入格式: 第一行输入作业数目，第二行输入作业的名字，第三行输入到达时间，第四行输入服务时间。 输出格式: 按照到达时间从小到大排序，第一行输出作业的名字，第二行输出到达时间，第三行输出服务时间，第四行输出完成时间，第五行输出完成时间，第六行输出带权周转时间。 下面展示一些. 输入样例: 在这里给出一组
操作系统——短作业优先调度算法
weixin_44620183的博客
06-02 1万+
操作系统——短作业优先调度算法 实验内容 模拟实现FCFS/SJF调度。 设置作业体：作业名，作业的到达时间，服务时间，作业状态（W——等待,R——运行,F——完成），作业间的链接指针； 作业初始化：由用户输入作业名、服务时间、到达时间进行初始化，同时，初始化作业的状态为W。 显示函数：在作业调度前、调度中和调度后进行显示。 排序函数：对等待状态的作业按照调度算法排序（不同的调度算法排序方式不同），注意考虑到达时间。 调度函数：每次从等待队列队首调度已到达的适合的作业执行，状态变化。当服务结束时，状态变为F
操作系统--作业调度算法：FCFS，SJF，HRN（python实现）
OLOFEMISTER的博客
10-30 1102
python实现操作系统的作业调度算法
模拟操作系统的进程调度，作业管理，设备分配，存储管理，
05-15
模拟操作系统的进程调度，作业管理，设备分配，存储管理，来实现判别一系列作业请求队列的响应顺序的要求
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码.zip
06-17
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码 问题描述 设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,...
FCFS和SJF进程调度算法实验报告
07-19
先来先服务和短作业优先
c语言实现 FCFS和SJF调度算法
04-19
c语言实现 FCFS和SJF调度算法 在vc6.0已经调试通过
FCFS和SJF调度算法java实现
04-23
FCFS和SJF调度算法java实现,这里输出界面友好，主要用eclispe编写的，计算了各个进程的性能指标和平均轮转时间等参数。
Scheduling_algo：操作系统调度算法，FCFS和SJF
02-04
操作系统调度算法 先来先服务（FCFS）和最短作业优先（SJF）调度 此代码是非抢占式的 这些算法是非抢占式或抢占式的。 非抢占式算法的设计使进程一旦进入运行状态，就无法抢占它，直到它完成其分配的时间为止，而...
实验一 FCFS和SJF调度算法.doc
05-07
实验一 FCFS和SJF调度算法.doc
FCFS和SJF进程调度算法实验报告.pdf
06-24
FCFS和SJF进程调度算法实验报告.pdfFCFS和SJF进程调度算法实验报告.pdfFCFS和SJF进程调度算法实验报告.pdfFCFS和SJF进程调度算法实验报告.pdfFCFS和SJF进程调度算法实验报告.pdfFCFS和SJF进程调度算法实验报告.pdf
请使用python实现FCFS和SJF作业调度算法
08-20
### 回答1： 您可以使用Python中的collections模块来实现FCFS和SJF作业调度算法。此模块提供了一个名为deque的数据结构，可以用来模拟堆栈，队列和双端队列。您可以使用这个数据结构来实现FCFS和SJF作业调度算法。 ### 回答2： FCFS(First-Come, First-Served)是一种先到先服务的作业调度算法。该算法根据作业到达的顺序分配CPU的执行时间。 下面是使用Python实现FCFS作业调度算法的示例代码： ```python def fcfs(arrival_time, burst_time): n = len(arrival_time) # 初始化等待时间和完成时间数组 waiting_time = [0] * n turnaround_time = [0] * n # 第一个作业的开始时间和完成时间等于到达时间和执行时间 turnaround_time[0] = burst_time[0] for i in range(1, n): # 当前作业的等待时间等于前一个作业的完成时间减去到达时间 waiting_time[i] = turnaround_time[i-1] - arrival_time[i] # 当前作业的完成时间等于等待时间加上执行时间 turnaround_time[i] = waiting_time[i] + burst_time[i] # 计算平均等待时间和平均周转时间 avg_waiting_time = sum(waiting_time) / n avg_turnaround_time = sum(turnaround_time) / n print("作业\t到达时间\t执行时间\t等待时间\t完成时间") for i in range(n): print(f"Job {i+1}\t{arrival_time[i]}\t\t{burst_time[i]}\t\t{waiting_time[i]}\t\t{turnaround_time[i]}") print("平均等待时间:", avg_waiting_time) print("平均周转时间:", avg_turnaround_time) # 示例输入 arrival_time = [0, 1, 2, 4] burst_time = [3, 5, 2, 1] # 调用算法实现 fcfs(arrival_time, burst_time) ``` SJF(Shortest Job First)是一种最短作业优先的作业调度算法。该算法根据作业的执行时间选择最短的作业来分配CPU的执行时间。 下面是使用Python实现SJF作业调度算法的示例代码： ```python def sjf(arrival_time, burst_time): n = len(arrival_time) # 初始化等待时间和完成时间数组 waiting_time = [0] * n turnaround_time = [0] * n # 创建列表来存储作业的剩余执行时间 remaining_time = burst_time[:] # 统计已经完成的作业数量 completed_jobs = 0 # 当还有作业未完成时，进行调度 while completed_jobs < n: # 初始化最小执行时间和最短作业索引 min_time = float('inf') shortest_job = None # 找到还未完成的作业中最短的执行时间 for i in range(n): if arrival_time[i] <= sum(turnaround_time[: completed_jobs]): if remaining_time[i] < min_time: min_time = remaining_time[i] shortest_job = i # 更新等待时间和周转时间 waiting_time[shortest_job] = sum(turnaround_time[: completed_jobs]) - arrival_time[shortest_job] turnaround_time[shortest_job] = waiting_time[shortest_job] + burst_time[shortest_job] # 标记作业为已完成 completed_jobs += 1 remaining_time[shortest_job] = float('inf') # 计算平均等待时间和平均周转时间 avg_waiting_time = sum(waiting_time) / n avg_turnaround_time = sum(turnaround_time) / n print("作业\t到达时间\t执行时间\t等待时间\t完成时间") for i in range(n): print(f"Job {i+1}\t{arrival_time[i]}\t\t{burst_time[i]}\t\t{waiting_time[i]}\t\t{turnaround_time[i]}") print("平均等待时间:", avg_waiting_time) print("平均周转时间:", avg_turnaround_time) # 示例输入 arrival_time = [0, 1, 2, 4] burst_time = [3, 5, 2, 1] # 调用算法实现 sjf(arrival_time, burst_time) ``` 以上代码分别实现了FCFS和SJF两种作业调度算法，可以根据不同的作业到达时间和执行时间，运行相应的示例输入来测试算法的实现和输出结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

苦笑的背后

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值