python实现FCFS算法

###先来先服务作业调度算法
import sys
#生成一个job
class Job:
    def __init__(self,task_id,arrive_time,run_time,level):
        self.arrive_time = arrive_time
        self.run_time = run_time
        self.level = level
        self.task_id = task_id


class Schedule:
    #任务队列
    procession = []
    #已存在任务队列id表
    procession_ids = []
     #
     #   运行细节情况:
     #   到达时间,运行完成时间,周转时间,带权周转时间
    runTaskDetail = []

    def __init__(self):
        pass
    
    def add_job(self,Job):
        if Job.task_id in self.procession_ids:
            print("任务ID:"+Job.task_id+"已存在,跳过")
        self.procession_ids.append(Job.task_id)
        self.procession.append(Job)    

    def run_job(self):

        #使用冒泡麦序算法将运行进度算一下
        sumTaskNum = len(self.procession_ids)
        for i in range(sumTaskNum - 1):
            for j in range(sumTaskNum - i - 1):
                if self.procession[j].arrive_time > self.procession[j+1].arrive_time:
                    self.procession[j],self.procession[j+1] = self.procession[j+1],self.procession[j]

  
        #总运行时间
        sumRunSeconds = 0
        
        #开始工作任务
        while self.procession:
            nowJob = self.procession[0]
            if nowJob.arrive_time > sumRunSeconds:
                sumRunSeconds = nowJob.arrive_time
            sumRunSeconds += nowJob.run_time
            revolve_time = sumRunSeconds-nowJob.arrive_time
            self.runTaskDetail.append({
                'task_id':nowJob.task_id,
                'arrive_time':nowJob.arrive_time,
                'run_time':nowJob.run_time,
                'revolve_time':revolve_time,
                'right_revolve_time':revolve_time // nowJob.run_time
            })
            self.procession.remove(nowJob)
            self.procession_ids.remove(nowJob.task_id)
            

def printProcessor(detail):
    print("到达时间|运行时间|周转时间|带权周转时间")
    count = len(detail)
    for i in range(count):
        print(str(detail[i]['arrive_time'])+"|"+str(detail[i]['run_time'])+"|"+str(detail[i]['revolve_time'])+"|"+str(detail[i]['right_revolve_time']))
        

if __name__ == "__main__":
    schedule = Schedule()
    schedule.add_job(Job(1, 0, 4, 6))
    schedule.add_job(Job(2, 2, 10, 7))
    schedule.add_job(Job(3, 3, 1, 12))
    schedule.add_job(Job(4, 5, 5, 1))
    schedule.add_job(Job(5, 4, 12, 4))
    schedule.run_job()
    printProcessor(schedule.runTaskDetail)
  • 7
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答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两种作业调度算法,可以根据不同的作业到达时间和执行时间,运行相应的示例输入来测试算法实现和输出结果。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值