操作系统原理进程调度
实验一、进程调度实验报告

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 CPU 资源给各个进程,以提高系统的整体性能和资源利用率。
通过本次实验,我们旨在深入理解进程调度的原理和算法,掌握进程状态的转换,观察不同调度策略对系统性能的影响,并通过实际编程实现来提高我们的编程能力和对操作系统概念的理解。
二、实验环境本次实验使用的操作系统为 Windows 10,编程语言为 C++,开发工具为 Visual Studio 2019。
三、实验原理1、进程状态进程在其生命周期中会经历不同的状态,包括就绪态、运行态和阻塞态。
就绪态表示进程已经准备好执行,只等待 CPU 分配;运行态表示进程正在 CPU 上执行;阻塞态表示进程由于等待某个事件(如 I/O操作完成)而暂时无法执行。
2、调度算法常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)等。
先来先服务算法按照进程到达的先后顺序进行调度。
短作业优先算法优先调度执行时间短的进程。
时间片轮转算法将 CPU 时间划分成固定大小的时间片,每个进程轮流获得一个时间片执行。
四、实验内容1、设计并实现一个简单的进程调度模拟器定义进程结构体,包含进程 ID、到达时间、执行时间、剩余时间等信息。
实现进程的创建、插入、删除等操作。
实现不同的调度算法。
2、对不同调度算法进行性能测试生成一组具有不同到达时间和执行时间的进程。
分别采用先来先服务、短作业优先和时间片轮转算法进行调度。
记录每个算法下的平均周转时间、平均等待时间等性能指标。
五、实验步骤1、进程结构体的定义```c++struct Process {int pid;int arrivalTime;int executionTime;int remainingTime;int finishTime;int waitingTime;int turnaroundTime;};```2、进程创建函数```c++void createProcess(Process processes, int& numProcesses, int pid, int arrivalTime, int executionTime) {processesnumProcessespid = pid;processesnumProcessesarrivalTime = arrivalTime;processesnumProcessesexecutionTime = executionTime;processesnumProcessesremainingTime = executionTime;numProcesses++;}```3、先来先服务调度算法实现```c++void fcfsScheduling(Process processes, int numProcesses) {int currentTime = 0;for (int i = 0; i < numProcesses; i++){if (currentTime < processesiarrivalTime) {currentTime = processesiarrivalTime;}processesistartTime = currentTime;currentTime += processesiexecutionTime;processesifinishTime = currentTime;processesiwaitingTime = processesistartTime processesiarrivalTime;processesiturnaroundTime = processesifinishTime processesiarrivalTime;}}```4、短作业优先调度算法实现```c++void sjfScheduling(Process processes, int numProcesses) {int currentTime = 0;int minExecutionTime, selectedProcess;bool found;while (true) {found = false;minExecutionTime = INT_MAX;selectedProcess =-1;for (int i = 0; i < numProcesses; i++){if (processesiarrivalTime <= currentTime &&processesiremainingTime < minExecutionTime &&processesiremainingTime > 0) {found = true;minExecutionTime = processesiremainingTime;selectedProcess = i;}}if (!found) {break;}processesselectedProcessstartTime = currentTime;currentTime += processesselectedProcessremainingTime;processesselectedProcessfinishTime = currentTime;processesselectedProcesswaitingTime =processesselectedProcessstartTime processesselectedProcessarrivalTime;processesselectedProcessturnaroundTime =processesselectedProcessfinishTime processesselectedProcessarrivalTime;processesselectedProcessremainingTime = 0;}}```5、时间片轮转调度算法实现```c++void rrScheduling(Process processes, int numProcesses, int timeSlice) {int currentTime = 0;Queue<int> readyQueue;for (int i = 0; i < numProcesses; i++){readyQueueenqueue(i);}while (!readyQueueisEmpty()){int currentProcess = readyQueuedequeue();if (processescurrentProcessarrivalTime > currentTime) {currentTime = processescurrentProcessarrivalTime;}if (processescurrentProcessremainingTime <= timeSlice) {currentTime += processescurrentProcessremainingTime;processescurrentProcessfinishTime = currentTime;processescurrentProcesswaitingTime =processescurrentProcessstartTime processescurrentProcessarrivalTime;processescurrentProcessturnaroundTime =processescurrentProcessfinishTime processescurrentProcessarrivalTime;processescurrentProcessremainingTime = 0;} else {currentTime += timeSlice;processescurrentProcessremainingTime = timeSlice;readyQueueenqueue(currentProcess);}}}```6、性能指标计算函数```c++void calculatePerformanceMetrics(Process processes, int numProcesses, double& averageWaitingTime, double& averageTurnaroundTime) {double totalWaitingTime = 0, totalTurnaroundTime = 0;for (int i = 0; i < numProcesses; i++){totalWaitingTime += processesiwaitingTime;totalTurnaroundTime += processesiturnaroundTime;}averageWaitingTime = totalWaitingTime / numProcesses; averageTurnaroundTime = totalTurnaroundTime / numProcesses;}```7、主函数```c++int main(){Process processes100;int numProcesses = 0;//创建进程createProcess(processes, numProcesses, 1, 0, 5);createProcess(processes, numProcesses, 2, 1, 3);createProcess(processes, numProcesses, 3, 2, 4);createProcess(processes, numProcesses, 4, 3, 2);//先来先服务调度fcfsScheduling(processes, numProcesses);double fcfsAverageWaitingTime, fcfsAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, fcfsAverageWaitingTime, fcfsAverageTurnaroundTime);cout <<"先来先服务调度的平均等待时间:"<<fcfsAverageWaitingTime << endl;cout <<"先来先服务调度的平均周转时间:"<<fcfsAverageTurnaroundTime << endl;//短作业优先调度sjfScheduling(processes, numProcesses);double sjfAverageWaitingTime, sjfAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, sjfAverageWaitingTime, sjfAverageTurnaroundTime);cout <<"短作业优先调度的平均等待时间:"<<sjfAverageWaitingTime << endl;cout <<"短作业优先调度的平均周转时间:"<<sjfAverageTurnaroundTime << endl;//时间片轮转调度(时间片为 2)rrScheduling(processes, numProcesses, 2);double rrAverageWaitingTime, rrAverageTurnaroundTime;calculatePerformanceMetrics(processes, numProcesses, rrAverageWaitingTime, rrAverageTurnaroundTime);cout <<"时间片轮转调度(时间片为 2)的平均等待时间:"<< rrAverageWaitingTime << endl;cout <<"时间片轮转调度(时间片为 2)的平均周转时间:"<< rrAverageTurnaroundTime << endl;return 0;}```六、实验结果与分析1、先来先服务调度平均等待时间:40平均周转时间:85分析:先来先服务调度算法简单直观,但对于短作业可能会造成较长的等待时间,导致平均等待时间和平均周转时间较长。
实验进程调度

淮海工学院计算机科学系实验报告书课程名:《操作系统原理》题目:实验一进程管理班级:Z软件52学号:2017140595姓名:郭文静1、实验目的与要求进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验要求用C/C++语言编写一个进程调度模拟程序,至少使用最高优先权优先或时间片轮转法两种算法来实现进程调度。
通过本实验可加深对进程调度算法的理解。
1、设计有5个进程并发执行的模拟调度程序,每个程序由一个PCB表示。
2、模拟调度程序至少使用最高优先权优先或时间片轮转法两种算法来实现进程调度。
3、程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。
2、实验内容或题目2.1优先级算法说明(1)PCB的结构:优先级算法中,设PCB的结构如右图所示,其中各数据项的含义Array如下:Id:进程标识符号,取值1—5。
Prior:优先级,随机产生,范围5—10。
Used:目前已占用的CPU时间数,初值为0;当该进程被调用执行时,每执行一个时间片,Used加1。
Need:进程尚需的CPU时间数,初值表示该进程需要运行的总时间,取值范围为1—5。
并随机产生,每运行一个时间片need减1;need为0则进程结束。
Status:进程状态R(运行),J(就绪),F(完成);初始时都处于就绪状态。
Next:指向就绪队列中下一个进程的PCB的指针。
(2)初始状态及就绪队列组织:5个进程初始都处于就绪状态,进程标识1—5,used初值都为0。
各进程的优先级随机产生,范围1—5。
处于就绪状态的进程,用队列加以组织,队列按优先级由高到低依次排列,队首指针设为head。
(3)调度原则以及运行时间的处理:正在执行的进程每执行一个时间片,其优先级减1(允许优先级为负)。
进程调度将在以下情况发生:当正在运行的程序其优先级小于就绪队列队首进程的优先级时。
程序中进程的运行时间以逻辑时间片为单位。
2.2时间片轮转算法说明(1)PCB的结构(如下图所示):轮转法中,设PCB的结构如右图所示,其中各数据项的含义如下:Span:在某一轮中,分配给先运行进程的时间片数,取值1—3。
操作系统进程调度实验

操作系统进程调度实验操作系统进程调度是操作系统中非常重要的一个功能,它决定了多个进程的执行顺序和调度策略。
进程调度的好坏直接影响着系统的性能和资源利用率。
本实验旨在通过实现一个简单的进程调度模拟,了解不同的调度算法,探讨其优劣和适用场景。
一、实验目的和原理本实验的目标是实现进程调度模拟,并探究不同调度算法的性能和适用场景。
通过实验,我们可以了解以下内容:1.进程调度算法的基本原理和实现方式;2.比较不同调度算法的优劣和特点;3.了解不同调度算法在不同场景下的应用。
二、实验环境和工具本实验使用C语言进行实现,可以选择任何一种编程环境和工具,例如Dev-C++、Visual Studio等。
三、实验过程及方法1.实现一个进程控制块(PCB)的数据结构,用来保存进程的相关信息,包括进程ID、进程状态、优先级等。
2.实现一个进程队列,用来保存就绪队列中的进程。
可以使用数组或链表等数据结构实现。
3. 实现不同调度算法的函数,包括先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)和时间片轮转(Round Robin)等。
4.根据实际需求生成一批进程,设置其信息,并根据不同算法进行调度。
5.对比不同算法的运行结果和性能,分析其优劣。
四、实验结果和分析通过实验,我们可以得到每个算法的平均等待时间、平均周转时间和吞吐量等性能指标。
根据这些指标,我们可以对不同算法进行评价和分析。
1.先来先服务(FCFS)算法FCFS算法是最简单的调度算法,按照进程到达的顺序进行调度。
它的主要优点是实现简单、公平性好。
然而,FCFS算法有明显的缺点,会导致长作业等待时间过长,产生"饥饿"现象。
2.最短作业优先(SJF)算法SJF算法是按照进程的执行时间长短进行调度的算法。
它能够最大限度地减少平均等待时间和周转时间,但是需要提前知道所有进程的执行时间,这在实际中是很难做到的。
linux下常见的调度策略及调度原理

linux下常见的调度策略及调度原理Linux是一种开源的操作系统,广泛应用于服务器和嵌入式设备中。
在Linux系统中,进程调度策略是操作系统的核心组成部分之一,它决定了进程的执行顺序和时间分配。
本文将介绍Linux下常见的调度策略及其调度原理。
在Linux系统中,常见的进程调度策略包括先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和优先级调度(Priority Scheduling)等。
先来先服务(FCFS)是一种简单而直观的调度策略,它按照进程到达的先后顺序进行调度。
即当一个进程到达系统时,它将被放入就绪队列的末尾,并等待CPU的分配。
当CPU空闲时,系统将选择就绪队列中的第一个进程分配给CPU执行。
这种调度策略的优点是公平性强,但缺点是无法处理长作业和短作业的差异,容易产生"饥饿"现象。
最短作业优先(SJF)调度策略是根据进程的执行时间来决定优先级的调度策略。
即系统会选择执行时间最短的进程先执行,以减少平均等待时间。
这种调度策略的优点是能够最大程度地减少平均等待时间,但缺点是可能会出现长作业等待时间过长的问题。
时间片轮转(RR)是一种基于时间片的调度策略,每个进程被分配一个固定长度的时间片。
当一个进程的时间片用完时,系统将把CPU分配给下一个进程。
这种调度策略的优点是能够有效地平衡进程之间的响应时间,但缺点是可能会导致频繁的上下文切换。
优先级调度(Priority Scheduling)是一种根据进程优先级来决定调度顺序的策略。
每个进程被分配一个优先级,优先级越高的进程越容易被调度执行。
这种调度策略的优点是能够根据不同进程的需求进行灵活调度,但缺点是可能会导致低优先级进程的"饥饿"问题。
在Linux系统中,调度算法的实现是通过内核的进程调度器来完成的。
内核中的调度器会根据不同的调度策略来选择下一个要执行的进程,并将其上下文切换到CPU中执行。
操作系统原理第五章处理器调度

2)正文段(共享正文段 ) 它是进程执行程序的一部分,可为多个进程共 享执行,作为正文段的程序必须是可重入的。
3)数据段 包括:正文段程序的处理对象--数据、进程 执 行 程 序 ( 私 有 ) 及 数 据 和 ppda( 进 程 数 据 区)。
4) 用户栈
2、UNIX进程树
0进程:系统初启时由系统初启程 序建立,完成系统初启的相应工 作后,创建1进程;然后的工作有 两项,其一是进程交换(进程图 象的管理);其二是进程切换 (进程调度)。
1 进程:为系统的每个联机终端 创建一个终端进程,然后就做托 管工作。
2、3、…、n、n+1进程:终端进 程,执行程序是shell,该进程执 行是接受和执行用户键入的shell 命令,或shell命令程序。
用户创建的进程:用户的shell命 令或shell程序所创建的进程;用 户在其程序中创建的进程。
三、进程调度
操作系统为了对进程进行有效的监控, 需要维护一些与进程相关的数据结构, 记录所有进程的运行情况,并在进程让 出处理器或调度程序剥夺处于运行状态 的进程占用的处理器时,选择适当的进 程分配处理器,完成上下文的切换。我 们把操作系统内核中完成这些功能的部 分称为进程调度。
1、进程调度的功能 1)记录系统中所有进程的执行情况 PCB 2)选择占有处理器的进程 3)进行进程上下文的切换 2、进程调度的方式 1)非剥夺调度方式 2)剥夺调度方式
p_flag中的SLOAD为1,表示该进程图象在 内存,否则不在内存。
(四)创建状态
父进程创建子进程时所处的状态,目的 是保证子进程能完全复制父进程的图象。
在UNIX系统中,父进程创建一个子进程 时,子进程要复制父进程的全部的进程 图象(除proc结构外),当有内存空间 时,能很快完成复制工作,但若无内存 空间时,就要在交换区中建立子进程图 象的复本,这时父进程将自己置为创建 状态,以保证自己的图象不被调出内存。
操作系统中的进程调度原理

操作系统中的进程调度原理一、概述进程调度在操作系统中是非常重要的一个概念。
它是指在系统中多个进程同时运行时,如何选择下一个要运行的进程,并对进程进行分配CPU时间片的过程。
进程调度在操作系统中扮演着重要的角色,它决定了系统整体的性能和响应时间。
在本文中,我们将详细讨论进程调度的原理、算法和实现,以及一些常见的调度策略。
二、进程调度的原理操作系统中的进程调度的本质是分配CPU资源。
CPU时间片是操作系统中进行任务调度的基本单位。
每个进程执行自己的任务时,都要先获得CPU时间片,进程使用的时间片用完之后,操作系统将紧接着将CPU资源分配给下一个进程运行。
在进程调度的过程中,操作系统需要维护一张任务调度表,该表中记录着每个进程的进程控制块(PCB),该表还需要维护一些其他的信息,如就绪进程队列、阻塞进程队列等。
每个进程具有自己的属性,如进程的优先级、占用CPU的时间等。
在进程调度的过程中,根据进程的优先级和占用CPU的时间来判断下一个将要运行的进程,并将CPU时间片分配给下一个进程。
三、进程调度的算法1.先来先服务(FCFS)先来先服务(FCFS)是最古老的进程调度算法。
这个算法的工作原理是,先到达的进程将拥有较高的优先级,并将首先获得CPU时间片运行。
虽然FCFS算法很容易实现,但它并不是最优的。
如果某个长时间运行的进程在队列前面,那么它将一直占用CPU资源,而其他进程会一直等待。
2.最短作业优先(SJF)最短作业优先(SJF)调度算法是根据每个任务占用的CPU时间来进行调度的。
该算法的工作流程如下:当进程到达时,根据其需要运行的时间将其放入队列中。
如果下一个就绪的任务的需要运行时间比当前运行的任务更短,那么该就绪任务将被优先执行。
但是,该算法也有一个问题,就是如果存在镰刀现象,即一些进程长时间等待,无法获得CPU时间片。
3.时间片轮转(RR)时间片轮转(RR)是一种分时系统调度算法。
正如其名字所暗示的那样,RR算法将相等的量分配给每个进程的时间片,每个进程在其时间片用完之前被调用,然后被挂起并在下一次被调用时恢复执行。
操作系统第3章 处理机调度(调度)
3.2 调度算法
进程调度的核心问题就是采用什么样的算法将处 理机分配给进程,常用的进程调度算法有:
先来先服务调度算法
短作业/进程优先调度算法
优先权调度算法
高响应比优先调度算法
时间片轮转调度算法
多级队列调度算法
多级反馈队列调度算法
返回目录
一、先来先服务调度算法FCFS
基本思想:按照进程进入就绪队列的 先后次序来分配处理机。
抢占(剥夺)方式
非抢占方式
一旦把处理机分配给某进程后,便让该进程 一直执行,直到该进程完成或因某事件而被 阻塞,才再把处理机分配给其它进程,不允 许进程抢占已分配出去的处理机。
特点:实现简单,系统开销小,常用于批处 理系统;但不利于处理紧急任务,故实时、 分时系统不宜采用。
抢占方式
允许调度程序根据某种原则(时间片、优 先权、短进程优先),停止正在执行的进 程,而将处理机重新分配给另一进程。
调度算法(太长---FCFS); 上下文切换(太短---上下文切换频繁); 平均周转时间。
短时间片增加上下文切换频率
周转时间随时间片变化
三、时间片轮转调度算法—例(1)
EG: 进程 到达时间
P1
0
P2
2
P3
4
P4
5
RR(时间片为1)
服务时间
7 4 1 4
P1 P2 P1 P2 P3 P1 P4 P2 P1 P4 P2 P1 P4 P1 P4
FCFS SPF-非 SPF-抢
周转T 124.25 100
75.75
等待T 74.25 49.5
25.25
二、SJF/SPF ——抢占式
到达顺序: 进程名 到达时间 服务时间
操作系统的调度名词解释
操作系统的调度名词解释作为计算机科学中的重要概念,操作系统的调度在计算机系统的运行中起到了至关重要的作用。
通过合理的调度算法,操作系统能够合理分配和管理计算机资源,提高系统的性能和效率。
本文将对操作系统调度中的一些重要名词进行解释,以帮助读者更好地理解和掌握这一领域。
1. 进程调度进程调度是操作系统中的一个重要概念,它指的是操作系统通过预设的调度算法,合理选择优先级最高的进程,并分配CPU时间片给该进程执行。
进程调度的目标是提高系统的性能和响应速度,以确保各个进程都能得到公平的执行机会。
常见的进程调度算法包括先来先服务、短作业优先、时间片轮转等。
2. 线程调度线程调度是对操作系统中线程的分配和执行进行管理和调度的过程。
线程调度的目标是合理分配CPU时间片,使得多个线程能够并发执行,以提高程序的效率和响应速度。
常见的线程调度算法有优先级调度、时间片轮转、多级反馈队列等。
3. 中断调度中断调度是操作系统对中断事件的处理和分配过程。
在计算机运行中,发生中断事件时,操作系统需要及时响应并进行相应的处理操作。
中断调度的目标是尽快响应中断事件,将控制权转移到相应的中断处理程序,并在处理完之后返回原来的进程继续执行。
4. IO调度IO调度是操作系统在处理IO请求时的调度过程。
由于独立于CPU的IO设备存在速度差异,操作系统需要合理调度IO请求的顺序和时间,以提高系统的整体性能和效率。
常用的IO调度算法有先来先服务、最短寻道时间优先、电梯算法等。
5. 内存调度内存调度是指操作系统对内存中进程的分配和管理过程。
在多道程序设计环境下,操作系统需要合理选择和分配内存资源,以提高系统的利用率和性能。
内存调度的目标是实现内存的最佳利用和动态分配。
常见的内存调度算法有分页调度、分段调度、段页式调度等。
6. 磁盘调度磁盘调度是指操作系统中对磁盘访问请求的调度过程。
由于磁盘访问需要相当的时间,操作系统需要选择合适的算法来优化磁盘访问顺序,以提高磁盘的读写效率和响应时间。
操作系统中进程管理的原理
操作系统中进程管理的原理操作系统是计算机系统中最为重要的软件之一,其作用是管理计算机的硬件和软件资源,为用户提供一个良好的使用环境。
进程管理是操作系统中的一个重要功能,其原理涉及到多个方面,包括进程的创建、退出、调度、通信等,具有重要的学习价值和实际应用价值。
本文将从进程的定义、特征和组成等方面入手,介绍操作系统中进程管理的原理。
一、进程的定义、特征和组成进程是指正在运行中的程序的一个实例,它是计算机系统中最基本的执行单元。
进程具有以下几个特征:1. 动态性:进程是动态的实体,可以被创建、终止或挂起。
2. 独立性:每个进程都有自己的虚拟地址空间和资源管理机制,能够独立地执行各自的任务。
3. 并发性:多个进程可以在同一时间内执行,实现系统的并发处理。
4. 同步性:进程之间可以通过共享内存、消息传递等方式进行通信和协作,实现数据的交换和同步。
进程由程序代码、数据、堆栈和系统资源等组成。
程序代码是进程的核心,它被存放在内存中,由CPU执行。
数据是进程运行时使用的变量、数组和结构等,它们保存在进程的堆和栈中。
堆是指程序运行时使用的动态分配内存,栈是指程序调用函数时使用的内存空间。
系统资源包括CPU、内存、输入输出设备等。
二、进程的创建和退出进程的创建包括进程控制块(PCB)的分配和初始化、地址空间的分配和初始化、程序代码的装入、系统资源的分配等步骤。
进程的退出则是相反的过程,包括系统资源的回收、地址空间的释放、PCB的回收等。
操作系统中进程的创建和退出通常通过系统调用实现。
在Linux中,创建进程的系统调用是fork(),退出进程的系统调用是exit()。
在Windows中,创建进程的系统调用是CreateProcess(),退出进程的系统调用是ExitProcess()。
三、进程的调度进程的调度是指进程在CPU上的分配和切换。
操作系统中使用多种调度算法对进程进行调度,如先来先服务(FCFS)、短作业优先(SJF)、时间片轮转等。
操作系统原理实训课程学习总结进程调度算法的实验验证与优化
操作系统原理实训课程学习总结进程调度算法的实验验证与优化在操作系统原理实训课程中,我深入学习了进程调度算法,并进行了实验验证与优化。
本文将对我在这门课程中的学习经历进行总结,并重点介绍我在进程调度算法实验方面的实践与优化。
一、学习经历总结在操作系统原理实训课程中,我通过理论学习和实践操作,全面了解了操作系统的基本概念和原理。
我通过学习教材、参与课堂讨论和实验操作,逐渐掌握了进程调度算法的相关知识和应用。
通过对课程的学习,我清楚地认识到进程调度在操作系统中的重要性。
合理的进程调度算法可以提高系统的运行效率和资源利用率,同时保证各个进程的公平性和优先级。
在学习的过程中,我学会了不同的进程调度算法,并了解了它们的特点和适用场景。
二、实验验证与优化为了深入理解和掌握进程调度算法,我进行了一系列的实验验证和优化。
以下是我进行的几个主要实验:1. 实验一:先来先服务(FCFS)调度算法通过模拟多个进程同时到达一个处理器,我验证了先来先服务调度算法的运行情况。
根据实验结果,我发现在进程的运行时间差异较大时,先来先服务调度算法可能会导致平均等待时间较长的问题。
为了优化这一问题,我尝试了引入响应比和时间片轮转等策略来改善进程调度效果。
2. 实验二:短作业优先(SJF)调度算法通过模拟多个进程以不同的作业时间到达处理器,我验证了短作业优先调度算法的运行情况。
实验结果表明,在作业时间相差较大时,短作业优先调度算法能够有效减少平均等待时间。
但是,当出现长作业阻塞短作业的情况时,短作业优先调度算法可能产生饥饿现象。
因此,在优化中,我考虑了引入抢占式调度策略以降低长作业优先级,解决饥饿问题。
3. 实验三:优先级调度算法通过设置不同优先级的进程,我验证了优先级调度算法的运行情况。
实验结果表明,优先级调度算法能够有效地保证高优先级进程的运行权。
但是,在进程优先级设置不当或者优先级反转等情况下,该算法可能产生不公平性问题。
为了解决这个问题,我优化了进程的优先级计算方法,采用动态调整的方式来提高调度算法的公平性。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
淮海工学院计算机科学系实验报告书
课程名:《操作系统原理》
题目:进程调度
班级:
学号:
姓名:
操作系统原理实验——进程调度实验报告
一、目的与要求
1)进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验要求用C 语言编写一个进程调度模拟程序,使用优先级或时间片轮转法实现进程调度。
本实验可加深对进程调度算法的理解。
2)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关实验数据与运行结果)
3)于2012年10月22日以前提交本次实验报告(含电子和纸质报告,由学习委员以班为单位统一打包提交)。
2 实验内容或题目
1)设计有5个进程并发执行的模拟调度程序,每个程序由一个PCB表示。
2)模拟调度程序可任选两种调度算法之一实现(有能力的同学可同时实现两个调度算法)。
3)程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。
4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。
3 实验步骤与源程序
//动态生成含有5个PCB的队列,并显示出来,代码自己补充
head=null;
rear=null;
for(i=1;i<=5;i++) //动态生成含5个元素的队列
{
temp=malloc(sizeof(struct PCB)); //动态分配一个PCB
temp->id=i;
temp->prior=rand()%5;
temp->status='W';
temp->used=0;
temp->need=rand()%5;
temp->next=null;
if (head==null)
{
head=temp;
rear=head;
}
else
{
rear->next=temp;
rear=temp;
}
}
//输出链表的所有元素
temp=head;
while(temp!=null)
{
printf("\t%d\t%d\t%c\t%d\n",temp->id,temp->prior,temp->status,temp->next);
temp=temp->next;
}
// 将队列按照优先级从大到小排序,并输出,
q=null;
while(head!=null)
{
temp=head;
small=head;
while(temp->next!=null) //找到最小的元素
{
if (temp->next->prior<small->prior)
{
small=temp->next;
}
temp=temp->next;
}
//将small指向的元素从head链表中移出,插入到q指向的链表
//首先定位到small元素的前一个元素
p=head;
if(p==small)
{
head=head->next;
p=small;
}
else
{
while(p->next!=small)
{
p=p->next;
}
}
//将P指向的元素插入Q为头指针的链表中
if (q==null)
{
p->next=small->next;
q=small;
q->next=null;
}
else
{
p->next=small->next;
small->next=q;
q=small;
}
}
//输出排序以后的链表的所有元素
head=q;
temp=head;
while(temp!=null)
{
printf("\n\t%d\t%d\t%c\t%d\n",temp->id,temp->prior,temp->status,temp->next);
temp=temp->next;
}
//将small指向的元素从head链表中移出,插入到q指向的链表
//首先定位到small元素的前一个元素
p=head;
if(p==small)
{
head=head->next;
p=small;
}
else
{
while(p->next!=small)
{
p=p->next;
}
}
//将P指向的元素插入Q为头指针的链表中
if (q==null)
{
p->next=small->next;
q=small;
q->next=null;
}
else
{
p->next=small->next;
small->next=q;
q=small;
}
}
//输出排序以后的链表的所有元素
head=q;
temp=head;
while(temp!=null)
{
printf("\n\t%d\t%d\t%c\t%d\n",temp->id,temp->prior,temp->status,temp->next);
temp=temp->next;
}
4 测试数据与实验结果(可以抓图粘贴)
5 结果分析与实验体会
本次实验全部都是在老师一步步的指导下完成的。
在做实验的过程中代码出现了许多的问题,通过老师发的源代码进行参考并反复的进行调试,最终才有了比较满意的结果。
对于不怎么喜欢敲代码的人来说,上这次试验,考验了自己的耐力与细心程度,还加强了与同学一起讨论和解决问题的能力。
这次能及时的完成调试,离不开老师在实验课上重复的讲解这实验的精髓,所以在以后实验课上还需要平时多听、多记才行。