操作系统实验 FCFS和短作业优先SJF调度算法模拟

进程调度模拟算法进程调度是操作系统中的重要组成部分之一，它负责决定在多道程序环境下，哪个进程将获得CPU的使用权。

进程调度模拟算法是为了研究和评估不同调度策略的性能而开发的一种仿真方法。

在实际系统中，调度算法会受到多种因素的影响，如进程优先级、进程的I/O需求、进程的实际执行时间等。

通过模拟这些因素，可以更好地理解不同调度算法之间的差异，并选择最合适的算法来满足特定需求。

下面介绍两种常见的进程调度模拟算法：先来先服务（FCFS）和最短作业优先（SJF）算法。

1. 先来先服务（FCFS）算法：该算法按照进程到达的顺序来调度任务。

当一个进程完成或阻塞时，下一个已到达的进程将获得CPU的使用权。

这种算法非常简单，但是不适用于长作业时间和短作业时间交替出现的情况。

在短作业启动时，长作业仍然在运行，使得短作业的等待时间增加。

2. 最短作业优先（SJF）算法：该算法根据任务的执行时间来调度进程。

在该算法中，每个进程的执行时间都是已知的，并且操作系统根据已知的执行时间来决定哪个进程获得CPU的使用权。

在短作业优先算法中，短作业将会先被调度，这样有助于减少平均周转时间和等待时间。

但是，短作业优先算法容易产生“饥饿”现象，即长作业可能会一直等待，而短作业一直得到CPU的使用权。

除了以上两种算法，还有其他的进程调度模拟算法。

例如：- 时间片轮转（RR）调度算法：使用固定的时间片来调度进程，当时间片用完后，该进程被放入就绪队列的末尾。

- 优先级调度算法：每个进程都拥有一个优先级，优先级越高的进程越早被调度。

这种方法可以根据不同进程的紧迫程度和重要性来进行调度。

- 多级反馈队列调度算法：将就绪队列划分为多个队列，并根据进程的性质和优先级将进程放入不同的队列。

每个队列都有不同的优先级和时间片大小，进程可以通过提高优先级或时间片大小来提高被调度的机会。

在实际应用中，需要根据系统需求和性能指标选择合适的调度算法。

常用的性能指标包括平均周转时间、平均等待时间、CPU利用率等。

操作系统进程调度算法模拟实验报告一、实验目的本实验旨在深入理解操作系统的进程调度算法，并通过模拟实验来探究不同调度算法之间的差异和优劣。

二、实验原理操作系统的进程调度算法是决定进程执行顺序的重要依据。

常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）、轮转法（Round Robin）和多级反馈队列调度（Multilevel Feedback Queue Scheduling）等。

1.先来先服务（FCFS）算法：按照进程到达的先后顺序进行调度，被调度的进程一直执行直到结束或主动阻塞。

2.最短作业优先（SJF）算法：按照进程需要的执行时间的短长程度进行调度，执行时间越短的进程越优先被调度。

3. 优先级调度（Priority Scheduling）算法：为每个进程分配一个优先级，按照优先级从高到低进行调度。

4. 轮转法（Round Robin）算法：将进程按照到达顺序排列成一个队列，每个进程被分配一个时间片（时间量度），当时间片结束时，将进程从队列头取出放置到队列尾。

5.多级反馈队列调度算法：将进程队列分为多个优先级队列，每个队列时间片大小依次递减。

当一个队列中的进程全部执行完毕或者发生阻塞时，将其转移到下一个优先级队列。

三、实验步骤与结果1.实验环境：- 操作系统：Windows 10- 编译器：gcc2.实验过程：（1）首先，设计一组测试数据，包括进程到达时间、需要的执行时间和优先级等参数。

（2）根据不同的调度算法编写相应的调度函数，实现对测试数据的调度操作。

（3）通过模拟实验，观察不同调度算法之间的区别，比较平均等待时间、完成时间和响应时间的差异。

（4）将实验过程和结果进行记录整理，撰写实验报告。

3.实验结果：这里列举了一组测试数据和不同调度算法的结果，以便对比分析：进程，到达时间，执行时间，优先------，----------，----------，-------P1，0，10，P2，1，1，P3，2，2，P4，3，1，P5，4，5，a.先来先服务（FCFS）算法：平均等待时间：3.8完成时间：15b.最短作业优先（SJF）算法：平均等待时间：1.6完成时间：11c. 优先级调度（Priority Scheduling）算法：平均等待时间：2.8完成时间：14d. 轮转法（Round Robin）算法：时间片大小：2平均等待时间：4.8完成时间：17e.多级反馈队列调度算法：第一级队列时间片大小：2第二级队列时间片大小：4平均等待时间：3.8完成时间：17四、实验总结通过上述的实验结果可以得出以下结论：1.在上述测试数据中，最短作业优先（SJF）算法的平均等待时间最短，说明该算法在短作业的情况下能够有效地减少等待时间。

先来先服务FCFS和短作业优先SJF进程调度算法实验一先来先服务FCFS和短作业优先SJF进程调度算法一需求分析【实验目的】通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

【实验内容】问题描述:设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。

假设有n个进程分别在T, … ,T时刻到达系统，它们需要的服1n务时间分别为S, … ,S。

分别采用先来先服务FCFS和短作业优先SJF1n进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。

程序需求:1,进程个数n,每个进程的到达时间T1, … ,Tn和服务时间S1, … ,Sn,2,要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的完成时间，周转时间和带权周转时间，并且计算所有进程的平均周转时间和带权平均周转时间,4,输出:输出计算出来的每个进程的完成时间，周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

5,测试数据:0 1 2 3 4 到达时间4 35 2 4 服务时间4 7 12 14 18 完成时间4 6 10 11 14 9 周转时间1 2 2 5.5 3.5 2.8 带权周转时间4 9 18 6 13 完成时间4 8 16 3 9 8 周转时间1 2.67 3.1 1.5 2.25 2.1 带权周转时间二概要设计1)程序中进程调度时间变量描述如下: const int MaxNum=100;//定义进程的最大总数 double ArrivalTime[MaxNum];到达时间double ServiceTime[MaxNum]; 服务时间 double FinishTime[MaxNum]; 完成时间double WholeTime[MaxNum]; 周转时间 double WeightWholeTime[MaxNum];带权周转时间 double AverageWT_FCFS; 定义FCFS平均周转时间 double AverageWWT_FCFS; 定义FCFS平均带权周转时间 double AverageWT_SJF; 定义SJF平均周转时间 double AverageWWT_SJF; 定义SJF平均带权周转时间2)进程调度的实现过程如下:, 变量初始化,, 接收用户输入n，T, … ,T，S, … ,S, 1n1n, 按照算法进行进程调度，计算进程的完成时间、周转时间和带权周转时间,, 计算所有进程的平均周转时间和平均带权周转时间, , 按格式输出调度结果。

操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法，通过编写代码模拟不同的调度算法，了解它们的特点和应用场景。

2. 实验环境本次实验使用的操作系统环境为Linux，并采用C语言进行编码。

3. 实验内容3.1 调度算法1：先来先服务（FCFS）FCFS调度算法是一种简单且常见的调度算法。

该算法按照进程到达的先后顺序进行调度。

在本实验中，我们使用C语言编写代码模拟FCFS算法的调度过程，并记录每个进程的等待时间、周转时间和响应时间。

3.2 调度算法2：最短作业优先（SJF）SJF调度算法是一种非抢占式的调度算法，根据进程的执行时间来选择下一个要执行的进程。

在本实验中，我们使用C语言编写代码模拟SJF算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。

3.3 调度算法3：轮转调度（Round Robin）Round Robin调度算法是一种经典的时间片轮转算法，每个进程在给定的时间片内依次执行一定数量的时间。

如果进程的执行时间超过时间片，进程将被暂时挂起，等待下一次轮转。

在本实验中，我们使用C语言编写代码模拟Round Robin算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。

4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析，可以得出以下结论：- FCFS算法适用于任务到达的先后顺序不重要的场景，但对于执行时间较长的进程可能会导致下一个进程需要等待较久。

- SJF算法适用于任务的执行时间差异较大的场景，能够提高整体执行效率。

- Round Robin算法适用于时间片相对较小的情况，能够公平地为每个进程提供执行时间。

5. 实验总结本次实验通过模拟不同调度算法的实际执行过程，深入了解了各种调度算法的原理、特点和适用场景。

通过对实验结果的分析，我们可以更好地选择合适的调度算法来满足实际应用的需求。

在后续的学习中，我们将进一步探索更多操作系统相关的实验和算法。

操作系统实验_先来先服务的调度算法及短作业优先1.引言操作系统的调度算法是指在多进程环境中，操作系统为进程分配CPU 的顺序和策略。

先来先服务（FCFS）调度算法是最简单的调度算法之一，它按照进程到达的顺序为其分配CPU。

而短作业优先（SJF）调度算法是根据进程的执行时间来为其分配CPU，执行时间越短的进程越先执行。

本文将分别介绍FCFS调度算法和SJF调度算法，并对其进行评价和比较。

2.先来先服务（FCFS）调度算法2.1调度原理FCFS调度算法的原理非常简单，按照进程到达的顺序为其分配CPU。

当一个进程进入就绪队列后，如果CPU空闲，则立即为其分配CPU。

如果CPU正忙，则进程进入等待队列，等待CPU空闲后再分配。

在该算法中，进程的运行时间不考虑，只考虑进程到达的时间。

2.2优点与缺点FCFS调度算法的主要优点是实现简单，无需对进程的运行时间进行估计。

但FCFS算法存在一定的缺点。

首先，长作业在短作业前面等待的时间较长，可能导致长作业的响应时间过长。

其次，如果有一个进程出现阻塞或响应时间过长，其后面的进程也会受到影响，造成整个系统的性能下降。

3.短作业优先（SJF）调度算法3.1调度原理短作业优先（SJF）调度算法是根据进程的执行时间来为其分配CPU。

当一个进程进入就绪队列后，如果其执行时间比当前正在运行的进程短，则优先为该进程分配CPU。

如果当前没有运行的进程或者当前运行的进程执行完毕，则立即为该进程分配CPU。

在该算法中，进程的到达时间不考虑，只考虑进程的执行时间。

3.2优点与缺点SJF调度算法的主要优点是可以最大程度地减少平均等待时间，提高系统的吞吐量。

短作业可以快速执行完毕，从而让更多的作业得以执行。

但SJF算法存在一定的缺点。

首先，需要对进程的执行时间有一个准确的估计，对于实时系统或动态系统来说，估计执行时间可能会有一定的误差。

其次，在长作业激增的情况下，短作业可能会一直得不到CPU的分配，造成长时间的等待。

先来先服务调度和最短作业优先调度算法实验报告实验报告一、实验目的本实验旨在通过编写代码实现先来先服务调度算法和最短作业优先调度算法，以深入理解和掌握这两种调度算法的原理和实现方法。

二、实验方法和原理1.先来先服务调度算法（FCFS）2.最短作业优先调度算法（SJF）最短作业优先调度算法是根据作业所需的运行时间进行调度的。

当一个作业到达并获得CPU后，系统会选择剩余运行时间最短的作业进行处理，这样可以最大化地提高系统的吞吐量。

三、实验过程与结果1.先来先服务调度算法的实现我们先定义一个作业类Job，其中包含作业名称、到达时间和运行时间等属性。

首先根据到达时间对作业队列进行排序，然后按照顺序执行作业，记录每个作业的开始时间、结束时间和周转时间等指标。

下面是先来先服务调度算法的代码实现部分：```pythonclass Job: = namedef fcfs_scheduler(jobs):for job in sorted_jobs:#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业fcfs_scheduler(jobs)#输出结果for job in jobs:```运行以上代码，会得到作业的开始时间、结束时间和周转时间等信息。

2.最短作业优先调度算法的实现最短作业优先调度算法需要知道每个作业的运行时间，而这个信息在实际情况中是未知的。

因此，我们可以先按到达时间对作业队列进行排序，然后在每个时间片中选择剩余运行时间最短的作业进行执行。

下面是最短作业优先调度算法的代码实现部分：```pythondef sjf_scheduler(jobs):while True:if not remaining_jobs:break#创建作业队列jobs =Job("Job1", 0, 3),Job("Job2", 1, 4),Job("Job3", 2, 2),Job("Job4", 4, 1)#调度作业sjf_scheduler(jobs)#输出结果for job in jobs:```运行以上代码，会得到相应的作业调度结果。

先来先服务FCFS和短作业优先SJF进程调度算法1、实验目的通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

2、需求分析(1) 输入的形式和输入值的范围输入值：进程个数Num 范围：0<Num<=100依次输入Num个进程的到达时刻范围：依次输入Num个进程的服务时刻范围：输入要使用的算法（1-FCFS，2-SJF）范围：1或者2(2) 输出的形式（X表示变量）时刻X：进程X开始运行。

其完成时刻：X 周转时刻：X 带权周转时刻：X…（省略（Num-1）个）平均周转时刻：X平均带权周转时刻：X(3) 程序所能达到的功能输入进程个数Num，每个进程到达时刻ArrivalTime[i]，服务时刻ServiceTime[i]。

采纳先来先服务FCFS或者短作业优先SJF进程调度算法进行调度，计算每个进程的完成时刻、周转时刻和带权周转时刻，同时统计Num个进程的平均周转时刻和平均带权周转时刻。

3、概要设计讲明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。

4、详细设计5、调试分析(1)调试过程中遇到的问题以及解决方法，设计与实现的回忆讨论和分析○1开始的时候没有推断进程是否到达，导致短进程优先算法运行结果错误，后来加上了推断语句后就解决了改问题。

○2差不多完成的设计所要实现的功能，总的来讲，FCFS编写容易，SJF需要先找到差不多到达的进程，再从差不多到达的进程里找到进程服务时刻最短的进程，再进行计算。

(2)算法的改进设想改进：即使用户输入的进程到达时刻没有先后顺序也能准确的计算出结果。

（确实是再加个循环，推断各个进程的到达时刻先后，组成一个有序的序列）(3)经验和体会通过本次实验，深入理解了先来先服务和短进程优先进程调度算法的思想，培养了自己的动手能力，通过实践加深了经历。

6、用户使用讲明（1）输入进程个数Num（2）依次输入Num个进程的到达时刻（3）依次输入Num个进程的服务时刻（4）选择要使用的算法7、测试结果正确一（FCFS）：正确一（SJF）：正确二（FCFS）：正确二（SJF）：错误（进程个数错误）：错误（选择算法错误）：8、附录//***************************************************** **************//** 进程调度算法 BY：09软件工程二班李群**//***************************************************** **************#include<iostream>#include<iomanip>using namespace std;static const int Max=100;int ArrivalTime[Max];//到达时刻int ServiceTime[Max];//服务时刻int FinishTime[Max];//完成时刻int WholeTime[Max];//周转时刻double WeightWholeTime[Max];//帯权周庄时刻double AverageWT_FCFS,AverageWT_SJF; //平均周转时刻double AverageWWT_FCFS,AverageWWT_SJF;//平均帯权周转时刻int ServiceTime_SJF[Max];//在SJF算法中使用到int Num=0;int NowTime=0;//记录当前时刻double SumWT=0,SumWWT=0;//SumWT用来计算总的周转时刻，SumWWT用来计算总的帯权周转时刻int i;int choice;//记录选择//***************************************************** *************// 先到先服务算法//***************************************************** *************void FCFS()//找最早到达的。

先来先服务FCFS和短作业优先SJF进程调度算法学生姓名:学生学号:专业班级:指导老师：2013年6月20日1、实验目的：通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

2、问题描述：假设有n个进程分别在T1, … ,T n时刻到达系统，它们需要的服务时间分别为S1, … ,S n。

分别采用先来先服务FCFS和短作业优先SJF 进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。

3、需求分析(1) 输入的形式和输入值的范围输入值：进程个数Num 范围：0<Num<=100 依次输入Num个进程的到达时间范围：依次输入Num个进程的服务时间范围：输入要使用的算法范围：1或者2 (2) 输出的形式（X表示变量）时刻X：进程X开始运行。

其完成时间：X周转时间：X带权周转时间：X…（省略（Num-1）个）平均周转时间：X平均带权周转时间：X(3) 程序所能达到的功能输入进程个数Num，每个进程到达时间ArrivalTime[i]，服务时间ServiceTime[i]。

采用先来先服务FCFS或者短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计Num个进程的平均周转时间和平均带权周转时间。

4、概要设计（1）程序中进程调度时间变量描述如下：（2）程序流程➢变量初始化；➢接收用户输入n，T1, … ,T n，S1, … ,S n；算法选择1-FCFS，2-SJF；➢按照选择算法进行进程调度，计算进程的完成时间、周转时间和带权周转时间；➢计算所有进程的平均周转时间和平均带权周转时间；按格式输出调度结果。

5、详细设计先来先服务算法：//******************************************************************// 先到先服务算法//******************************************************************void FCFS() //找最早到达的。

操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能，它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。

为了更好地理解进程调度算法的工作原理，我们可以进行一个模拟实验来观察不同算法的表现效果。

实验设想：我们设想有5个进程要运行在一个单核处理器上，每个进程有不同的运行时间和优先级。

进程信息如下：进程A：运行时间10ms，优先级4进程B：运行时间8ms，优先级3进程C：运行时间6ms，优先级2进程D：运行时间4ms，优先级1进程E：运行时间2ms，优先级5实验步骤：1.先来先服务（FCFS）调度算法实验：将上述进程按照先来先服务的原则排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。

2.最短作业优先（SJF）调度算法实验：将上述进程按照运行时间的大小排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。

3.优先级调度算法实验：将上述进程按照优先级的大小排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。

4.时间片轮转（RR）调度算法实验：设置一个时间片大小，将上述进程按照先来先服务的原则排序，运行对应的模拟程序，观察每个进程的运行时间、完成时间和等待时间。

实验结果：通过模拟实验，我们可以得到每个进程的运行时间、完成时间和等待时间。

对于FCFS算法，进程的运行顺序是按照先来先服务的原则，因此进程A首先得到处理器资源并完成运行，其它进程依次按照到达顺序得到资源。

因此，对于进程A、B、C、D、E，它们的完成时间分别是10ms、18ms、24ms、28ms和30ms，等待时间分别是0ms、10ms、18ms、24ms和28ms。

对于SJF算法，进程的运行顺序是按照运行时间的大小，即短作业优先。

因此，进程E首先得到处理器资源并完成运行，其它进程依次按照运行时间的大小得到资源。

对于进程E、D、C、B、A，它们的完成时间分别是2ms、6ms、12ms、20ms和30ms，等待时间分别是0ms、2ms、6ms、12ms和20ms。

操作系统实验报告实验一先来先服务FCFS和短作业优先SJF进程调度算法学号：班级：姓名：【实验题目】：先来先服务FCFS和短作业优先SJF进程调度算法【实验目的】通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

【实验内容】问题描述：设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。

假设有n 个进程分别在T1, … ,T n时刻到达系统，它们需要的服务时间分别为S1, … ,S n。

分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。

程序要求如下：1）进程个数n；每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n；选择算法1-FCFS，2-SJF。

2）要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间；3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间，带权周转时间，所有进程的平均周转时间，带权平均周转时间。

实现提示：用C++语言实现提示：1）程序中进程调度时间变量描述如下：static int MaxNum=100;int ArrivalTime[MaxNum];int ServiceTime[MaxNum];int FinishTime[MaxNum];int WholeTime[MaxNum];double WeightWholeTime[MaxNum];double AverageWT_FCFS,AverageWT_SJF;double AverageWWT_FCFS,AverageWWT_SJF;2）进程调度的实现过程如下：变量初始化；接收用户输入n，T1, … ,T n，S1, … ,S n；算法选择1-FCFS，2-SJF；按照选择算法进行进程调度，计算进程的完成时间、周转时间和带权周转时间；计算所有进程的平均周转时间和平均带权周转时间；按格式输出调度结果。

进程调度模拟程序实验实验报告一、实验目的进程调度是操作系统的核心功能之一，它负责合理地分配 CPU 资源给各个进程，以提高系统的性能和效率。

本次实验的目的是通过编写和模拟进程调度程序，深入理解不同的进程调度算法的原理和特点，并比较它们在不同情况下的性能表现。

二、实验环境本次实验使用的编程语言为 Python，开发环境为 PyCharm。

操作系统为 Windows 10。

三、实验原理1、先来先服务（FCFS）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度，先到达的进程先获得 CPU 资源。

2、短作业优先（SJF）调度算法短作业优先调度算法优先调度执行时间短的进程。

3、时间片轮转（RR）调度算法时间片轮转调度算法将 CPU 时间划分为固定大小的时间片，每个进程轮流获得一个时间片的 CPU 资源。

四、实验设计1、进程类的设计创建一个进程类，包含进程 ID、到达时间、服务时间、剩余服务时间等属性，以及用于更新剩余服务时间和判断进程是否完成的方法。

2、调度算法实现分别实现先来先服务、短作业优先和时间片轮转三种调度算法。

3、模拟流程（1）初始化进程列表。

（2）按照选定的调度算法进行进程调度。

（3）计算每个进程的等待时间、周转时间等性能指标。

五、实验步骤1、定义进程类｀｀｀pythonclass Process:def ＿_init__(self, pid, arrival_time, service_time)：selfpid ＝ pidselfarrival_time ＝ arrival_timeselfservice_time ＝ service_timeselfremaining_service_time ＝ service_time｀｀｀2、先来先服务调度算法实现｀｀｀pythondef fcfs_scheduling(process_list)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0for process in process_list:if current_time ＜ processarrival_time:current_time ＝ processarrival_timewaiting_time ＝ current_time processarrival_timetotal_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processservice_timeturnaround_time ＝ current_time processarrival_timetotal_turnaround_time ＋＝ turnaround_timeaverage_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂先来先服务调度算法的平均等待时间：＂，average_waiting_time)print(＂先来先服务调度算法的平均周转时间：＂，average_turnaround_time)｀｀｀3、短作业优先调度算法实现｀｀｀pythondef sjf_scheduling(process_list)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0sorted_process_list ＝ sorted(process_list, key=lambda x: xservice_time) for process in sorted_process_list:if current_time ＜ processarrival_time:current_time ＝ processarrival_timewaiting_time ＝ current_time processarrival_timetotal_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processservice_timeturnaround_time ＝ current_time processarrival_timetotal_turnaround_time ＋＝ turnaround_timeaverage_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂短作业优先调度算法的平均等待时间：＂，average_waiting_time)print(＂短作业优先调度算法的平均周转时间：＂，average_turnaround_time)｀｀｀4、时间片轮转调度算法实现｀｀｀pythondef rr_scheduling(process_list, time_slice)：current_time ＝ 0total_waiting_time ＝ 0total_turnaround_time ＝ 0ready_queue ＝while len(process_list) ＞ 0 or len(ready_queue) ＞ 0:for process in process_list:if processarrival_time ＜＝ current_time:ready_queueappend(process)process_listremove(process)if len(ready_queue) ＝＝ 0:current_time ＋＝ 1continueprocess ＝ ready_queuepop(0)if processremaining_service_time ＜＝ time_slice: waiting_time ＝ current_time processarrival_time total_waiting_time ＋＝ waiting_timecurrent_time ＋＝ processremaining_service_time turnaround_time ＝ current_time processarrival_time total_turnaround_time ＋＝ turnaround_time processremaining_service_time ＝ 0else:waiting_time ＝ current_time processarrival_time total_waiting_time ＋＝ waiting_timecurrent_time ＋＝ time_sliceprocessremaining_service_time ＝ time_sliceready_queueappend(process)average_waiting_time ＝ total_waiting_time ／ len(process_list)average_turnaround_time ＝ total_turnaround_time ／ len(process_list) print(＂时间片轮转调度算法（时间片大小为"， time_slice, ＂）的平均等待时间：＂， average_waiting_time)print(＂时间片轮转调度算法（时间片大小为"， time_slice, ＂）的平均周转时间：＂， average_turnaround_time)｀｀｀5、主函数｀｀｀pythonif ＿_name__ ＝＝＂＿_main__"：process_list ＝Process(1, 0, 5)，Process(2, 1, 3)，Process(3, 2, 8)，Process(4, 3, 6)print(＂先来先服务调度算法：＂）fcfs_scheduling(process_list)print(＂短作业优先调度算法：＂）sjf_scheduling(process_list)time_slice ＝ 2print(＂时间片轮转调度算法（时间片大小为"，time_slice, ＂）：＂）rr_scheduling(process_list, time_slice)｀｀｀六、实验结果与分析1、先来先服务调度算法平均等待时间为 575，平均周转时间为 1275。

操作系统实验报告一[实验题目]先来先服务FCFS和短作业优先SJF调度算法[实验目的]通过本次实验，加深对进城概念的理解，进一步掌握对进城状态转变、进城调度策略及对系统性能的评价方法。

[实验内容]编程实现如下内容：1.先来先服务算法；2.短进程优先算法；3.根据调度顺序计算所有作业的平均周转时间及平均带权周转时间。

代码如下：一、先来先服务算法代码#include<stdio.h>#include<stdlib.h>/**@author*@date 2015-6-1*/typedef struct process_FCFS{float arrivetime; //到达时间float servetime; //服务时间float finishtime; //完成时间float roundtime; //周转时间float daiquantime; //带权周转时间struct process_FCFS *link; //结构体指针}FCFS;FCFS *p,*q,*head=NULL;struct process_FCFS a[100];struct process_FCFS *sortarrivetime(struct process_FCFS a[],int n) {int i,j;struct process_FCFS t;int flag;for(i=1;i<n;i++){flag=0;for(j=0;j<n-i;j++){if(a[j].arrivetime>a[j+1].arrivetime){t=a[j];a[j]=a[j+1];a[j+1]=t;flag=1;}}if(flag==0)//如果排序中没发生任何交换，则结束break;}return a;}//先来先服务算法void print(struct process_FCFS a[],int n){int i;for(i=0;i<n;i++){printf("到达时间：%f",a[i].arrivetime);printf("服务时间：%f",a[i].servetime);printf("完成时间：%f",a[i].finishtime);printf("周转时间：%f",a[i].roundtime);printf("带权周转时间：%f",a[i].daiquantime);printf("\n");}}void Fcfs(struct process_FCFS a[],int n){int i;a[0].finishtime=a[0].arrivetime+a[0].servetime;a[0].roundtime=a[0].finishtime+a[0].arrivetime;a[0].daiquantime=a[0].roundtime/a[0].servetime; for(i=0;i<n;i++){if(a[i].arrivetime<a[i-1].finishtime){a[i].finishtime=a[i-1].finishtime+a[i].servetime;a[i].roundtime=a[i].finishtime-a[i].arrivetime;a[i].daiquantime=a[i].roundtime/a[i].servetime; }else{a[i].finishtime=a[i].arrivetime+a[i].servetime;a[i].roundtime=a[i].finishtime-a[i].arrivetime;a[i].daiquantime=a[i].roundtime/a[i].servetime; }}printf("先来先服务\n");print(a,n);}void main(){int n,i;printf("请输入有几个进程\n");scanf("%d",&n);for(i=0;i<n;i++){printf("arrivetime");scanf("%f",&a[i].arrivetime);printf("servetime");scanf("%f",&a[i].servetime);}Fcfs(a,n);}二、短作业优先算法代码#include<iostream.h>#include<stdio.h>struct pcb{char pno;int come_time; //到达时间int run_time; //服务时间};float fcfs(pcb pro[],int n){struct pcb temp;int i,j,k; //time为当前时间float weight_time=0,time=0; //记录周转时间的和//temp=(pcb)malloc(sizeof(pcb));cout<<"进程调度情况如下:"<<endl;cout<<"进程号到达时间服务时间周转时间:"<<endl;//选择排序过程,按到达时间升序排列for(i=0;i<n-1;i++){k=i;for(j=i+1;j<n;j++)if(pro[k].come_time>pro[j].come_time)k=j;if(k!=i){temp=pro[i];pro[i]=pro[k];pro[k]=temp;}}for(i=0;i<n;i++){ time+=pro[i].run_time;weight_time+=(time-pro[i].come_time)/pro[i].run_time;//(time-pro[i].come_time)/pro[i].run_time为排序后第i个进程的周转时间cout<<pro[i].pno<<" "<<pro[i].come_time<<" "<<pro[i].run_time<<""<<(time-pro[i].come_time)/pro[i].run_time<<endl;}return weight_time/=n; //返回平均带权周转时间}void insert(pcb pro[],pcb pro1,int start,int end)//将一pcb类型的元素插入到有序数组中，最后还保持有序{int i=end;while((i--)>start)if(pro[i].run_time>pro1.run_time)pro[i+1]=pro[i];pro[i]=pro1;}float sjp(pcb pro[],int n){int i,first=0,count,flag[20],k,min;float time=0,weight_time=0;//调度第一个到达内存的进程for(i=1;i<n;i++){if(pro[first].come_time>pro[i].come_time) first=i;flag[i]=0;}flag[first]=1;time=(float)pro[first].run_time;weight_time=1;cout<<pro[first].pno<<" "<<pro[first].come_time<<" "<<pro[first].run_time<<" "<<weight_time<<endl;//pro_temp[0]=pro[first];count=n-1;while(count){k=0;min=32767; //设置一个较大的阈值，for(i=0;i<n;i++) //找到一个未被访问的，作业较短的且已经到达内存的作业调度if((i!=first)&&(flag[i]==0)&&(time>=pro[i].come_time)&&(min>pro[i]. run_time)){k=i;min=pro[i].run_time;}flag[k]=1; //访问后置标记为访问time+=pro[k].run_time;weight_time+=(time-pro[k].come_time)/pro[k].run_time;cout<<pro[k].pno<<" "<<pro[k].come_time<<" "<<pro[k].run_time<<""<<(time-pro[k].come_time)/pro[k].run_time<<endl;count--; //每调度一个作业，count减1}return weight_time/=n;}void main(){pcb pro[5]={{'C',2,5},{'A',0,4},{'B',1,3},{'D',3,2},{'E',4,4}};cout<<fcfs(pro,5)<<endl;cout<<sjp(pro,5)<<endl;}[实验结果]（抓图）先来先服务算法截图短作业优先截图[心得体会]1、通过实验，我加深了对进程的了解2、了解了先来先服务算法和短作业算法的特征和区别。

以下参考的别人的：FCFS和SJF调度算法思想和实现算法算法思想:设计程序模拟进程的先来先效劳FCFS和短作业优先SJF调度过程。

假设有n个进程分别在T1, …,T n时刻到达系统，它们需要的效劳时间分别为S1, … ,S n。

分别采用先来先效劳FCFS和短作业优先SJF 进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。

源程序:#include <iomanip.h>#include <iostream.h>staticconstint N=100;intarrivalTime[N];//到达时间intserviceTime[N];//效劳时间intfinishTime[N];//完成时间intWholeTime[N];//周转时间double WeightWholeTime[N];//带权周转时间double averageWT,averageWWT;//平均周转时间intserviceTime_SJF[N];int n=0;intnowTime=0;//记录当前时间inti;{cout<<"\n=========================FCFS调度算法=========================\n";for(i=0;i<n;i++){if(arrivalTime[i]>nowTime)nowTime=arrivalTime[i];nowTime+=serviceTime[i];finishTime[i]=nowTime;}for(inti=0;i<n;i++)WholeTime[i]=finishTime[i]-arrivalTime[i];for(inti=0;i<n;i++)WeightWholeTime[i]=(double)WholeTime[i]/(double)serviceTime[i];for(inti=0;i<n;i++){averageWT+=(double)WholeTime[i]/n;averageWWT+=(double)WeightWholeTime[i]/n;}}{cout<<"\n==========================SJF调度算法=========================\n";int min=0;nowTime=arrivalTime[0]+serviceTime[0];finishTime[0]=nowTime;serviceTime_SJF[0]=100;intallin=0,j,k;for(i=1;i<n;i++){k=1;min=0;if(allin==0){j=0;while(arrivalTime[j]<=nowTime&& j<n){j++;if(j>n)allin=1;}}elsej=n;j=j-1;while(k<=j){if(serviceTime_SJF[k]==0)k++;else{if(serviceTime_SJF[min]>serviceTime_SJF[k])min=k;k++;}}serviceTime_SJF[min]=0;nowTime+=serviceTime[min];finishTime[min]=nowTime;}for(inti=0;i<n;i++)WholeTime[i]=finishTime[i]-arrivalTime[i];for(inti=0;i<n;i++)WeightWholeTime[i]=(double)WholeTime[i]/(double)serviceTime[i];averageWT=0;averageWWT=0;for(inti=0;i<n;i++){averageWT+=(double)WholeTime[i]/n;averageWWT+=(double)WeightWholeTime[i]/n;}}void sortOn()//进程按照到达或者效劳时间进行排序{int temp;for(inti=0;i<n;i++)for(int k=0;k<n-i-1;k++)if(arrivalTime[k+1]<arrivalTime[k]){temp=arrivalTime[k+1];arrivalTime[k+1]=arrivalTime[k];arrivalTime[k]=temp;temp=serviceTime[k+1];serviceTime[k+1]=serviceTime[k];serviceTime[k]=temp;}}void input(){cout<<"请输入进程的个数：";cin>>n;cout<<endl;while(n>100||n<=0){cout<<"进程个数必须大于0且小于等于100！请重新输入进程个数"<<endl;}cout<<"请输入这"<<N<<"个进程的到达时间：\n\n";for(inti=0;i<n;i++)//设置N个进程的到达时间{int M;cin>>M;arrivalTime[i]=M;}cout<<endl;cout<<"请输入这"<<N<<"个进程的对应的效劳时间：\n\n";for(inti=0;i<n;i++)//设置N个进程的效劳时间{int M;cin>>M;serviceTime[i]=M;serviceTime_SJF[i]=M;}cout<<endl;cout<<"您输入的这"<<N<<"个进程的信息如下：\n\n";sortOn();//进程按照到达时间进行排序cout<<"进程名\t\t";for(inti=0;i<n;i++){char c=i+65;cout<<c<<"\t";}cout<<"\n到达时间\t";for(inti=0;i<n;i++)cout<<arrivalTime[i]<<"\t";cout<<"\n效劳时间\t";for(inti=0;i<n;i++)cout<<serviceTime[i]<<"\t";cout<<endl<<endl;}void output(){cout<<"进程名\t\t";for(inti=0;i<n;i++){char c=i+65;cout<<c<<"\t";}cout<<"平均\n到达时间\t";for(inti=0;i<n;i++)cout<<arrivalTime[i]<<"\t"; cout<<"\n效劳时间\t";for(inti=0;i<n;i++)cout<<serviceTime[i]<<"\t";cout<<"\n完成时间\t";for(inti=0;i<n;i++)cout<<finishTime[i]<<"\t";cout<<"\n周转时间\t";for(inti=0;i<n;i++)cout<<WholeTime[i]<<"\t";cout<<averageWT<<setprecision(3)<<"\n带权周转时间\t";for(inti=0;i<n;i++)cout<<WeightWholeTime[i]<<"\t";cout<<averageWWT<<setprecision(3)<<endl;}void main(){cout<<"\n\n========================FCFS和SJF调度算法======================\n\n";input();FCFS();output();//getchar();SJF();output();char c;cin>>c;getchar();}。

FCFS和SJF进程调度算法实验报告材料讲解实验目的：1.了解先来先服务（FCFS）和短作业优先（SJF）进程调度算法的工作原理；2.掌握进程调度算法的模拟过程；3.理解不同调度算法对系统性能的影响。

实验原理：1.先来先服务（FCFS）调度算法：按照进程到达的先后顺序进行调度，先到达的进程先被执行。

2.短作业优先（SJF）调度算法：选取就绪队列中所需处理时间最短的进程进行执行。

实验过程：1. 设计进程控制块（Process Control Block，PCB）数据结构，包括进程ID、到达时间、服务时间、开始时间、完成时间、周转时间和带权周转时间等字段；2.根据实验要求创建若干个进程，并随机生成不同的到达时间和服务时间，初始化进程控制块；3.按照先来先服务（FCFS）调度算法对创建的进程进行调度，并记录各个进程的开始时间和完成时间；4.根据完成时间计算周转时间和带权周转时间；5.按照短作业优先（SJF）调度算法对创建的进程进行调度，并记录各个进程的开始时间和完成时间；6.根据完成时间计算周转时间和带权周转时间；7.分析比较两种调度算法的结果，评估其对系统性能的影响。

实验结果：以三个进程为例，分别为进程A、进程B和进程C，到达时间和服务时间如下：进程到达时间服务时间A010B26C441.先来先服务（FCFS）调度算法：按照进程到达的先后顺序进行调度。

进程到达时间服务时间开始时间完成时间周转时间带权周转时间A010010101.0B261016142.3C441620164.02.短作业优先（SJF）调度算法：选取就绪队列中所需处理时间最短的进程进行执行。

进程到达时间服务时间开始时间完成时间周转时间带权周转时间A010010101.0C441014102.5B261420183.0实验分析：从实验结果可以看出，在先来先服务（FCFS）调度算法中，进程A先到达，所以先执行，然后进程B、C依次执行。

由于进程B和进程C的到达时间间隔较小，导致进程B等待的时间较长，所以其带权周转时间最长。

进程号到达时刻服务时间(⼩时)A9:002B9:301C9:400.5D10:300.4进程号到达时刻服务时间（⼩时）开始时间完成时间周转时间（⼩时）带权周转时间A9:00291121B9:3011112 2.5 2.5C9:400.51212:30 2.83 5.66D10:300.412:3012:54 2.46操作系统——先来先服务（FCFS ）和短作业优先（SJF ）调度算法例题：计算在单CPU 环境下,采⽤FCFS 调度算法、SJF 优先调度算法时的平均周转时间和平均带权周转时间,并指出它们的调度顺序。

公式：周转时间 = 完成时间 - 到达时间带权周转时间 = 周转时间 / 服务时间平均周转时间 = 周转时间 / 进程数量平均带权周转时间 = 带权周转时间 / 进程数量完成时间的计算⽅法不同，分别如下：先来先服务（FCFS ）调度算法：FCFS 调度顺序：A 、B 、C 、D （先来先服务）FCFS 完成时间：A (完成时间)=A (到达时间)+A (服务时间)=9+2=11B (完成时间)=A (完成时间)+B (服务时间)=11+1=12C (完成时间)=B (完成时间)+C (服务时间)D (完成时间)=C (完成时间)+D (服务时间)（该进程完成时间 =上⼀进程的完成时间 + 这个进程的服务时间）单位要转化进程号到达时刻服务时间（⼩时）开始时间完成时间周转时间（⼩时）带权周转时间A9:00291121B9:30111:5412:54 3.4 3.4C9:400.511:2411:54 2.4 4.8D10:300.41111:240.9 2.25平均周转时间：（2+2.5+2.38+2.4）/4=2.32平均带权周转时间：（1+2.5+5.66+6）/4=3.79短作业优先（SJF ）调度算法：SJF 调度顺序：A 、D 、C 、BSJF 完成时间： A(完成时间)=A(到达时间)+A(服务时间) D(完成时间)=A(到达时间)+D(服务时间) C(完成时间)=D(到达时间)+C(服务时间) B(完成时间)=C(到达时间)+B(服务时间)平均周转时间： （2+3.4+2.45+0.9）/4=2.6875平均带权周转时间： （1+3.4+4.8+2.25）/4=2.8625。

先来先服务FCFS和短作业优先SJF进程调度算法_实验报告材料一、实验目的本实验的目的是通过编写程序模拟先来先服务(FCFS)和短作业优先(SJF)进程调度算法，并对其效果进行评估，从而对两种算法有一个更直观的认识。

二、实验原理2. 短作业优先(Shortest-Job-First, SJF)进程调度算法：根据进程的执行时间进行调度，选择执行时间最短的进程先执行。

三、实验步骤1. 设计进程类Process，包含进程名称、到达时间、执行时间等属性，并重载比较运算符以便后续排序。

2. 设计FCFS调度算法函数fcfs_scheduling，实现进程按照先来先服务的规则进行调度。

3. 设计SJF调度算法函数sjf_scheduling，实现进程按照执行时间最短的规则进行调度。

4. 编写主函数，分别调用fcfs_scheduling和sjf_scheduling函数，并根据实际情况输出结果，比较两种算法的效果。

四、实验结果与分析1.输入样例：进程A：到达时间0，执行时间3进程B：到达时间1，执行时间4进程C：到达时间2，执行时间2进程D：到达时间4，执行时间12.输出结果：FCFS调度结果：A->B->C->D，平均等待时间为(0+3+7+9)/4=4.75SJF调度结果：A->C->B->D，平均等待时间为(0+1+3+6)/4=2.53.结果分析：从结果可以看出，短作业优先(SJF)进程调度算法能够更好地减少进程的等待时间，因为它根据进程的执行时间进行调度，优先执行执行时间较短的进程。

与之相比，先来先服务(FCFS)进程调度算法无法对不同进程的执行时间进行判断，可能导致执行时间较短的进程等待时间长。

五、实验总结通过本次实验，我对先来先服务(FCFS)和短作业优先(SJF)进程调度算法有了更深入的了解。

先来先服务(FCFS)算法简单直观，但无法保证最优解；短作业优先(SJF)算法可以减少进程的等待时间，但需要预知每个进程的执行时间。

操作系统实验_先来先服务的调度算法和短作业优先先来先服务（FCFS）调度算法是一种非抢占式调度算法，在这种算法中，进程按照到达系统的先后顺序执行，并且在一个进程执行完毕之前，不会有其他进程执行。

如果一个进程没有执行完成，后续进程需要等待。

FCFS调度算法的优点是实现简单，公平性好。

由于按照到达时间先后顺序执行进程，能够保证所有进程都能够得到执行的机会。

然而，FCFS调度算法容易出现“饥饿”现象，即如果一个进程占用了较长的CPU时间，其他进程可能需要等待较长时间。

短作业优先（SJF）调度算法是一种非抢占式调度算法，它选择下一个执行的进程是根据预计的执行时间最短的进程。

在SJF调度算法中，进程按照预计的执行时间进行排序，并按照顺序执行。

SJF调度算法的优点是能够最大程度地减少平均等待时间。

因为进程按照预计的执行时间最短的顺序执行，执行时间短的进程优先执行，可以最大限度地减少其他进程等待的时间。

然而，SJF调度算法需要预先知道所有进程的执行时间，并且如果一个进程执行时间长，其他进程需要等待的时间可能会很长。

FCFS调度算法和SJF调度算法都有各自的优点和局限性。

FCFS调度算法适用于进程执行时间相对均匀的情况，可以保证所有进程都能够得到执行的机会。

但是，如果一个进程执行时间很长，可能会导致其他进程等待的时间非常长，容易出现“饥饿”现象。

SJF调度算法适用于进程执行时间差异较大的情况，可以最大程度地减少平均等待时间。

但是，SJF调度算法需要预先知道所有进程的执行时间，而且在实际应用中，很难准确预测进程的执行时间。

在实验中，可以通过编写相应的模拟程序来实现FCFS调度算法和SJF调度算法。

可以设定一个进程队列，每个进程有自己的到达时间和执行时间。

按照FCFS算法，按照到达时间先后顺序执行进程；按照SJF算法，按照执行时间从小到大的顺序执行进程。

通过模拟进程的调度过程，可以观察到FCFS算法和SJF算法的效果差异。