操作系统 FCFS,SPF,HRRN算法的实现

简介: 操作系统 FCFS,SPF,HRRN算法的实现

FCFS,SPF,HRRN算法的实现

  • 先来先服务(first-come first-served,FCFS)调度算法 
    该算法是一种最简单的调度算法,它既可用于作业调度,也可用于进程调度。在进程调度中采用 FCFS 算法时, 将选择最先进入就绪队列的进程投入执行。 FCFS 算法属于非抢占调度方式, 其特点是简单、易于实现 , 但不利于短作业和 I/0 型作业的运行。FCFS 算法很少作为进程调度的主算法,但常作为辅助调度算法。
  • 短作业(进程)优先调度算法SJ/PF
    该调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行
    image.png
  • 高响应比优先调度算法 HRRN
    高响应比优先调度算法则是既考虑了作业的等待时间,又考虑作业运行时间的调度算法该优先权的变化规律可描述为:
    image.png
  • 代码
#include<stdio.h>
typedef struct PCB{
  int ID;    //进程ID 
  double submit;     //提交时间 
  double run;    //运行时长 
  double start;  //开始时间 
  double end;    //结束时间 
  double TAT;  //周转
  double TATW;    //带权周转
}PCB;
void FCFS(PCB pcb[], int PCBNUM){      
  //先来先服务
  PCB temp;  //方便交换 
  for(int i = 0; i < PCBNUM - 1; i++){                 
    for(int j = 0; j < PCBNUM - i - 1; j++){
      if(pcb[j].submit > pcb[j+1].submit){
        //使用冒泡排序,通过提交时间经行排序 
        temp = pcb[j];
          pcb[j] = pcb[j+1];
        pcb[j+1] = temp;
      }
      }
    }
  for(int i = 0; i < PCBNUM; i++){    
    //时间计算
    if(i == 0){
      pcb[i].start = pcb[i].submit;
    }
    else{
      pcb[i].start = pcb[i-1].end;
    }
    pcb[i].end = pcb[i].start + pcb[i].run;
    pcb[i].TAT = pcb[i].end - pcb[i].submit;
    pcb[i].TATW = pcb[i].TAT / pcb[i].run;
  }
  printf("FCFS,先来先服务算法:\n");
  printf("名称    提交    运行    开始    结束    周转    带权周转\n");
  for(int i = 0; i < PCBNUM; i++){   
      //输出
    printf("%d\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\n", pcb[i].ID, pcb[i].submit, pcb[i].run, pcb[i].start, pcb[i].end, pcb[i].TAT, pcb[i].TATW);
  }
  printf("\n");
}
void SPF(PCB pcb[], int PCBNUM){     
  //短进程优先 
  PCB temp;  //方便交换 
  for(int r = PCBNUM - 1; r > 0; r--){
    //选出第一行
    if(pcb[r-1].submit > pcb[r].submit){
      temp = pcb[r];
        pcb[r] = pcb[r-1];
      pcb[r-1] = temp;
    }
  }
  for(int i = 1; i < PCBNUM - 1; i++){        
    for(int j = 1; j < PCBNUM - 1; j++){
      //通过运行时间排序 
      if(pcb[j].run > pcb[j+1].run ){
        temp = pcb[j];
          pcb[j] = pcb[j+1];
        pcb[j+1] = temp;
      }
      }
  }
  for(int i = 0; i < PCBNUM; i++){     //计算
    if(i == 0){
      pcb[i].start = pcb[i].submit;
    }
    else{
      pcb[i].start = pcb[i-1].end;
    }
    pcb[i].end = pcb[i].start +pcb[i].run;
    pcb[i].TAT = pcb[i].end -pcb[i].submit;
    pcb[i].TATW = pcb[i].TAT/pcb[i].run ;    
  }
  printf("SPF,短进程优先算法:\n");
  printf("名称    提交    运行    开始    结束    周转    带权周转\n");
  for(int i = 0; i < PCBNUM; i++){   
      //输出
    printf("%d\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\n", pcb[i].ID, pcb[i].submit, pcb[i].run, pcb[i].start, pcb[i].end, pcb[i].TAT, pcb[i].TATW);
  }
  printf("\n");
}
void HRRN(PCB pcb[], int PCBNUM){          
  //高响应比
  PCB temp;  //方便交换
  int R[PCBNUM];  //记录相应比 
  for(int r = PCBNUM-1; r > 0; r--){    
      //选出第一行
    if(pcb[r-1].submit > pcb[r].submit){
      temp = pcb[r];
        pcb[r] = pcb[r-1];
      pcb[r-1] = temp;
    }
  }
  for(int i = 0; i < PCBNUM - 1; i++){               
    for(int j=1;j < PCBNUM - 1; j++){
      //排序,通过响应比 
      for(int o = 1; o < PCBNUM; o++){     
         //计算响应比
        R[i] = (pcb[i-1].end-pcb[i].submit) / pcb[i].run+1;
      }
      if(R[i] < R[i+1]){
        temp = pcb[j];
          pcb[j] = pcb[j+1];
        pcb[j+1] = temp;
      }
    }
  }
  for(int i = 0; i < PCBNUM; i++){     
    //计算
    if(i == 0){
      pcb[i].start = pcb[i].submit;
    }
    else{
      pcb[i].start = pcb[i-1].end;
    }
    pcb[i].end = pcb[i].start + pcb[i].run;
    pcb[i].TAT = pcb[i].end - pcb[i].submit;
    pcb[i].TATW = pcb[i].TAT / pcb[i].run;
    }
    printf("HRRN,高响应比算法:\n");
    printf("名称    提交    运行    开始    结束    周转    带权周转\n");
  for(int i = 0; i < PCBNUM; i++){   
      //输出
    printf("%d\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\n", pcb[i].ID, pcb[i].submit, pcb[i].run, pcb[i].start, pcb[i].end, pcb[i].TAT, pcb[i].TATW);
  }
  printf("\n");
}
int main(){
  printf("请输入进程数目:");
  int PCBNUM;
  scanf("%d", &PCBNUM);
  PCB pcb[PCBNUM];  //申请空间 
  printf("请输入每个进程的进程名,提交时间,运行时长(中间用空格分开)\n"); 
  for(int i = 0; i < PCBNUM; i++){
    scanf("%d%lf%lf", &pcb[i].ID, &pcb[i].submit, &pcb[i].run);
  }
  FCFS(pcb, PCBNUM);
  SPF(pcb, PCBNUM);
  HRRN(pcb, PCBNUM);
}
  • 效果图image.png


目录
相关文章
|
2月前
|
算法 调度 UED
探索操作系统的心脏:调度算法的奥秘与影响
【10月更文挑战第9天】 本文深入探讨了操作系统中至关重要的组件——调度算法,它如同人体的心脏,维持着系统资源的有序流动和任务的高效执行。我们将揭开调度算法的神秘面纱,从基本概念到实际应用,全面剖析其在操作系统中的核心地位,以及如何通过优化调度算法来提升系统性能。
|
1月前
|
算法 调度 Python
深入理解操作系统中的进程调度算法
在操作系统中,进程调度是核心任务之一,它决定了哪个进程将获得CPU的使用权。本文通过浅显易懂的语言和生动的比喻,带领读者了解进程调度算法的重要性及其工作原理,同时提供代码示例帮助理解。
|
1月前
|
存储 算法 网络协议
OSPF的SPF算法介绍:原理、实现与应用
OSPF的SPF算法介绍:原理、实现与应用
84 3
|
1月前
|
算法 大数据 Linux
深入理解操作系统之进程调度算法
【10月更文挑战第24天】本文旨在通过浅显易懂的语言,带领读者深入了解操作系统中的进程调度算法。我们将从进程的基本概念出发,逐步解析进程调度的目的、重要性以及常见的几种调度算法。文章将通过比喻和实例,使复杂的技术内容变得生动有趣,帮助读者建立对操作系统进程调度机制的清晰认识。最后,我们还将探讨这些调度算法在现代操作系统中的应用和发展趋势。
|
2月前
|
算法 调度 UED
深入理解操作系统的进程调度算法
【10月更文挑战第7天】在操作系统的心脏——内核中,进程调度算法扮演着至关重要的角色。它不仅影响系统的性能和用户体验,还直接关系到资源的合理分配。本文将通过浅显易懂的语言和生动的比喻,带你一探进程调度的秘密花园,从最简单的先来先服务到复杂的多级反馈队列,我们将一起见证算法如何在微观世界里编织宏观世界的和谐乐章。
|
2月前
|
边缘计算 算法 调度
探究操作系统的心脏:调度算法的进化与影响
【10月更文挑战第2天】 本文深入探讨了操作系统中核心组件——调度算法的历史演变、关键技术突破及其对现代计算的影响。通过详细回顾从单任务到多任务、实时系统及分布式计算环境下调度算法的发展,文章揭示了这些算法如何塑造我们的数字世界,并对未来的趋势进行了展望。不同于传统的摘要,本文特别聚焦于技术细节与实际应用的结合点,为读者提供一幅清晰的技术演进蓝图。
70 4
|
2月前
|
算法 调度 UED
探索操作系统的心脏:进程调度算法
【9月更文挑战第32天】在数字世界的每一次心跳中,都隐藏着一个不为人知的英雄——进程调度算法。它默默地在后台运作,确保我们的命令得到快速响应,应用程序平稳运行。本文将带你走进操作系统的核心,一探进程调度的奥秘,并通过代码示例揭示其背后的智慧。准备好跟随我一起深入这趟技术之旅了吗?让我们开始吧!
|
3月前
|
算法 调度
操作系统的心脏:深入解析进程调度算法
本文旨在深入探讨现代操作系统中的核心功能之一——进程调度。进程调度算法是操作系统用于分配CPU时间片给各个进程的机制,以确保系统资源的高效利用和公平分配。本文将详细介绍几种主要的进程调度算法,包括先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)以及优先级调度(PS)。我们将分析每种算法的基本原理、优缺点及其适用场景。同时,本文还将讨论多级反馈队列(MFQ)调度算法,并探讨这些算法在实际应用中的表现及未来发展趋势。通过深入解析这些内容,希望能够为读者提供对操作系统进程调度机制的全面理解。
|
3月前
|
存储 算法 前端开发
深入理解操作系统:进程调度与优先级队列算法
【9月更文挑战第25天】在操作系统的复杂世界中,进程调度是维持系统稳定运行的核心机制之一。本文将深入探讨进程调度的基本概念,分析不同的进程调度算法,并着重介绍优先级队列算法的原理和实现。通过简洁明了的语言,我们将一起探索如何优化进程调度,提高操作系统的效率和响应速度。无论你是计算机科学的初学者还是希望深化理解的专业人士,这篇文章都将为你提供有价值的见解。
|
3月前
|
人工智能 算法 大数据
探究操作系统的心脏:调度算法的进化与影响
本文深入探讨了操作系统中核心组件——调度算法的发展及其对系统性能的影响。通过分析先来先服务、短作业优先、时间片轮转等传统调度算法,阐述了它们的原理和优缺点。同时,讨论了现代调度算法如多级队列和优先级调度在提高系统响应速度和处理能力方面的作用。文章还探讨了实时系统中的调度挑战,以及如何通过优化调度策略来满足不同应用场景下的性能需求。