计算机操作系统进程调度实验研究报告

合集下载

操作系统实验报告进程调度

操作系统实验报告进程调度

操作系统实验报告进程调度操作系统实验报告:进程调度引言在计算机科学领域中,操作系统是一个重要的概念,它负责管理和协调计算机系统中的各种资源,包括处理器、内存、输入/输出设备等。

其中,进程调度是操作系统中一个非常重要的组成部分,它负责决定哪个进程在何时获得处理器的使用权,以及如何有效地利用处理器资源。

实验目的本次实验的目的是通过对进程调度算法的实验,深入理解不同的进程调度算法对系统性能的影响,并掌握进程调度算法的实现方法。

实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。

在该计算机上,我们使用了C语言编写了一些简单的进程调度算法,并通过模拟不同的进程调度场景进行了实验。

实验内容1. 先来先服务调度算法(FCFS)先来先服务调度算法是一种简单的进程调度算法,它按照进程到达的顺序进行调度。

在本次实验中,我们编写了一个简单的FCFS调度算法,并通过模拟多个进程同时到达的情况,观察其对系统性能的影响。

2. 短作业优先调度算法(SJF)短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。

在本次实验中,我们编写了一个简单的SJF调度算法,并通过模拟不同长度的进程,观察其对系统性能的影响。

3. 时间片轮转调度算法(RR)时间片轮转调度算法是一种按照时间片大小进行调度的算法。

在本次实验中,我们编写了一个简单的RR调度算法,并通过模拟不同时间片大小的情况,观察其对系统性能的影响。

实验结果通过实验,我们发现不同的进程调度算法对系统性能有着不同的影响。

在FCFS 算法下,长作业会导致短作业等待时间过长;在SJF算法下,长作业会导致短作业饥饿现象;而RR算法则能够较好地平衡不同进程的执行。

因此,在实际应用中,需要根据具体情况选择合适的进程调度算法。

结论本次实验通过对进程调度算法的实验,深入理解了不同的进程调度算法对系统性能的影响,并掌握了进程调度算法的实现方法。

同时,也加深了对操作系统的理解,为今后的学习和研究打下了良好的基础。

实验一、进程调度实验报告

实验一、进程调度实验报告

实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 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分析:先来先服务调度算法简单直观,但对于短作业可能会造成较长的等待时间,导致平均等待时间和平均周转时间较长。

操作系统实验报告进程调度

操作系统实验报告进程调度

操作系统实验报告进程调度操作系统实验报告:进程调度引言操作系统是计算机系统中最核心的软件之一,它负责管理和调度计算机的资源,提供良好的用户体验。

在操作系统中,进程调度是其中一个重要的功能,它决定了进程的执行顺序和时间片分配,对于提高计算机系统的效率和响应能力至关重要。

本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。

一、进程调度的概念进程调度是操作系统中的一个重要组成部分,它负责决定哪个进程可以使用CPU,并为其分配执行时间。

进程调度的目标是提高系统的吞吐量、响应时间和公平性。

在多道程序设计环境下,进程调度需要考虑多个进程之间的竞争和协作,以实现资源的合理利用。

二、进程调度算法1. 先来先服务调度(FCFS)先来先服务调度算法是最简单的进程调度算法之一,它按照进程到达的顺序进行调度,即先到达的进程先执行。

这种算法的优点是公平性高,缺点是无法适应长作业和短作业混合的情况,容易产生"饥饿"现象。

2. 最短作业优先调度(SJF)最短作业优先调度算法是根据进程的执行时间来进行调度的,即执行时间最短的进程先执行。

这种算法的优点是能够最大程度地减少平均等待时间,缺点是无法适应实时系统和长作业的情况。

3. 时间片轮转调度(RR)时间片轮转调度算法是一种抢占式调度算法,它将CPU的执行时间划分为固定大小的时间片,并按照轮转的方式分配给各个进程。

当一个进程的时间片用完后,它将被挂起,等待下一次调度。

这种算法的优点是能够保证每个进程都能够获得一定的执行时间,缺点是无法适应长作业和短作业混合的情况。

4. 优先级调度(Priority Scheduling)优先级调度算法是根据进程的优先级来进行调度的,优先级高的进程先执行。

这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度,缺点是可能会导致低优先级的进程长时间等待。

三、实验结果与分析在实验中,我们使用了不同的进程调度算法,并对其进行了性能测试。

进程调度实验报告

进程调度实验报告

进程调度实验报告一、实验目的。

本实验旨在通过对进程调度算法的模拟和实验,加深学生对进程调度原理的理解,掌握各种进程调度算法的特点和应用场景,提高学生的实际操作能力和分析问题的能力。

二、实验环境。

本次实验使用了C语言编程语言,通过模拟实现了先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和多级反馈队列(MFQ)四种进程调度算法。

三、实验过程。

1. 先来先服务(FCFS)调度算法。

先来先服务调度算法是一种非抢占式的调度算法,按照进程到达的先后顺序进行调度。

在本次实验中,我们通过模拟多个进程到达并排队等待CPU执行,观察其平均等待时间和平均周转时间。

实验结果表明,先来先服务调度算法适用于作业长度差异较大的情况,但容易产生“饥饿”现象。

2. 最短作业优先(SJF)调度算法。

最短作业优先调度算法是一种非抢占式的调度算法,按照作业执行时间的长短进行调度。

在本次实验中,我们通过模拟多个作业的执行时间,观察其平均等待时间和平均周转时间。

实验结果表明,最短作业优先调度算法能够最大程度地减少平均等待时间,但可能会导致长作业被“饿死”。

3. 时间片轮转(RR)调度算法。

时间片轮转调度算法是一种抢占式的调度算法,每个进程被分配一个时间片,当时间片用完后,该进程被放到队尾等待。

在本次实验中,我们通过模拟多个进程的执行和时间片的调度,观察其平均等待时间和平均周转时间。

实验结果表明,时间片轮转调度算法能够保证每个进程都能得到一定的执行时间,但可能会导致上下文切换频繁。

4. 多级反馈队列(MFQ)调度算法。

多级反馈队列调度算法是一种综合性的调度算法,根据进程的优先级和执行时间进行动态调整。

在本次实验中,我们通过模拟多个进程的执行和不同优先级队列的调度,观察其平均等待时间和平均周转时间。

实验结果表明,多级反馈队列调度算法能够兼顾短作业和长作业,提高了系统的整体性能。

四、实验总结。

通过本次实验,我们深入理解了不同进程调度算法的特点和适用场景。

进程调度操作系统实验报告

进程调度操作系统实验报告

进程调度操作系统实验报告一、实验目的本次实验的主要目的是深入理解操作系统中进程调度的概念和原理,通过实际编程和模拟,观察不同调度算法对系统性能的影响,并掌握进程调度的实现方法。

二、实验环境操作系统:Windows 10编程语言:C++开发工具:Visual Studio 2019三、实验原理进程调度是操作系统的核心功能之一,它负责决定哪个进程在何时获得 CPU 资源进行执行。

常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、时间片轮转(RR)、优先级调度等。

先来先服务算法按照进程到达的先后顺序进行调度,先到达的进程先获得 CPU 执行。

这种算法简单直观,但可能导致短作业等待时间过长。

短作业优先算法优先调度执行时间短的进程,能有效减少平均等待时间,但可能导致长作业饥饿。

时间片轮转算法将 CPU 时间划分成固定大小的时间片,每个进程轮流获得一个时间片进行执行。

如果进程在时间片内未完成,则被放回就绪队列等待下一轮调度。

优先级调度根据进程的优先级来决定调度顺序,优先级高的进程先获得 CPU 资源。

四、实验步骤1、设计进程结构体定义进程的标识号(PID)、到达时间、服务时间、剩余时间、优先级等属性。

2、实现先来先服务算法按照进程到达的先后顺序将它们放入就绪队列。

从就绪队列中取出第一个进程进行调度执行,直到其完成。

3、实现短作业优先算法计算每个进程的剩余服务时间。

将进程按照剩余服务时间从小到大排序,放入就绪队列。

从就绪队列中取出剩余服务时间最短的进程进行调度执行。

4、实现时间片轮转算法设定时间片大小。

将进程放入就绪队列,按照先来先服务的原则依次分配时间片执行。

进程在时间片内未完成的,放回就绪队列末尾。

5、实现优先级调度算法为每个进程设置优先级。

将进程按照优先级从高到低排序,放入就绪队列。

从就绪队列中取出优先级最高的进程进行调度执行。

6、计算平均周转时间和平均带权周转时间周转时间=完成时间到达时间带权周转时间=周转时间/服务时间平均周转时间=总周转时间/进程数平均带权周转时间=总带权周转时间/进程数7、输出调度结果包括每个进程的调度顺序、开始时间、结束时间、周转时间、带权周转时间等。

实验进程调度的实验报告

实验进程调度的实验报告

一、实验目的1. 加深对进程概念和进程调度算法的理解。

2. 掌握进程调度算法的基本原理和实现方法。

3. 培养编程能力和系统分析能力。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验内容1. 实现进程调度算法2. 创建进程控制块(PCB)3. 模拟进程调度过程四、实验原理进程调度是操作系统核心功能之一,负责将CPU分配给就绪队列中的进程。

常见的进程调度算法有先来先服务(FCFS)、短作业优先(SJF)、优先级调度、时间片轮转(RR)等。

1. 先来先服务(FCFS)算法:按照进程到达就绪队列的顺序进行调度。

2. 短作业优先(SJF)算法:优先调度运行时间最短的进程。

3. 优先级调度算法:根据进程的优先级进行调度,优先级高的进程优先执行。

4. 时间片轮转(RR)算法:每个进程分配一个时间片,按顺序轮流执行,时间片结束后进行调度。

五、实验步骤1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、运行时间、优先级、状态等信息。

2. 创建进程队列,用于存储就绪队列、等待队列和完成队列。

3. 实现进程调度算法:a. FCFS算法:按照进程到达就绪队列的顺序进行调度。

b. SJF算法:优先调度运行时间最短的进程。

c. 优先级调度算法:根据进程的优先级进行调度。

d. 时间片轮转(RR)算法:每个进程分配一个时间片,按顺序轮流执行。

4. 模拟进程调度过程:a. 初始化进程队列,将进程添加到就绪队列。

b. 循环执行调度算法,将CPU分配给就绪队列中的进程。

c. 更新进程状态,统计进程执行时间、等待时间等指标。

d. 当进程完成时,将其移至完成队列。

六、实验结果与分析1. FCFS算法:按照进程到达就绪队列的顺序进行调度,简单易实现,但可能导致短作业等待时间过长。

2. SJF算法:优先调度运行时间最短的进程,能提高系统吞吐量,但可能导致进程饥饿。

进程管理实验报告分析(3篇)

进程管理实验报告分析(3篇)

第1篇一、实验背景进程管理是操作系统中的一个重要组成部分,它负责管理计算机系统中所有进程的创建、调度、同步、通信和终止等操作。

为了加深对进程管理的理解,我们进行了一系列实验,以下是对实验的分析和总结。

二、实验目的1. 加深对进程概念的理解,明确进程和程序的区别。

2. 进一步认识并发执行的实质。

3. 分析进程争用资源的现象,学习解决进程互斥的方法。

4. 了解Linux系统中进程通信的基本原理。

三、实验内容1. 使用系统调用fork()创建两个子进程,父进程和子进程分别显示不同的字符。

2. 修改程序,使每个进程循环显示一句话。

3. 使用signal()捕捉键盘中断信号,并通过kill()向子进程发送信号,实现进程的终止。

4. 分析利用软中断通信实现进程同步的机理。

四、实验结果与分析1. 实验一:父进程和子进程分别显示不同的字符在实验一中,我们使用fork()创建了一个父进程和两个子进程。

在父进程中,我们打印了字符'a',而在两个子进程中,我们分别打印了字符'b'和字符'c'。

实验结果显示,父进程和子进程的打印顺序是不确定的,这是因为进程的并发执行。

2. 实验二:每个进程循环显示一句话在实验二中,我们修改了程序,使每个进程循环显示一句话。

实验结果显示,父进程和子进程的打印顺序仍然是随机的。

这是因为并发执行的进程可能会同时占用CPU,导致打印顺序的不确定性。

3. 实验三:使用signal()捕捉键盘中断信号,并通过kill()向子进程发送信号在实验三中,我们使用signal()捕捉键盘中断信号(按c键),然后通过kill()向两个子进程发送信号,实现进程的终止。

实验结果显示,当按下c键时,两个子进程被终止,而父进程继续执行。

这表明signal()和kill()在进程控制方面具有重要作用。

4. 实验四:分析利用软中断通信实现进程同步的机理在实验四中,我们分析了利用软中断通信实现进程同步的机理。

进程调度 实验报告

进程调度 实验报告

进程调度实验报告进程调度实验报告概述:进程调度是操作系统中一个重要的组成部分,它负责决定在多个进程同时运行时,每个进程分配到的CPU时间片以及切换进程的时机。

合理的进程调度算法能够提高系统的性能和资源利用率,因此对进程调度的研究和优化具有重要意义。

1. 背景介绍进程调度是操作系统中的一个关键任务,它负责管理和控制多个进程的执行顺序,以实现对CPU的合理分配。

在多道程序设计环境下,进程调度的作用尤为重要。

进程调度算法的好坏直接影响着系统的性能和响应速度。

2. 进程调度算法2.1 先来先服务(FCFS)先来先服务是最简单的调度算法之一,它按照进程到达的先后顺序进行调度,即先到达的进程先执行,直到该进程执行完成或者发生I/O操作。

FCFS算法的优点是公平且易于实现,但是它无法适应不同进程的执行时间差异,可能导致长作业效应。

2.2 最短作业优先(SJF)最短作业优先调度算法是根据进程的执行时间长度来进行调度,执行时间越短的进程越优先执行。

SJF算法能够最大程度地减少平均等待时间,但是它需要预先知道进程的执行时间,这在实际应用中往往是不可行的。

2.3 时间片轮转(RR)时间片轮转是一种经典的调度算法,它将CPU的执行时间划分为若干个时间片,每个进程在一个时间片内执行,如果时间片用完还没有执行完,则将该进程放入就绪队列的末尾,继续执行下一个进程。

RR算法能够保证每个进程都能获得公平的CPU时间,但是对于长时间执行的进程,会导致较大的上下文切换开销。

3. 实验设计与结果分析为了评估不同进程调度算法的性能,我们设计了一系列实验。

首先,我们使用不同的进程到达时间和执行时间生成一组测试数据。

然后,分别使用FCFS、SJF和RR算法进行调度,并记录每个进程的等待时间和周转时间。

最后,我们对实验结果进行分析。

实验结果显示,FCFS算法对于执行时间较长的进程会出现较长的平均等待时间,而SJF算法能够有效减少平均等待时间。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

计算机操作系统进程调度实验研究报告————————————————————————————————作者:————————————————————————————————日期:操作系统实验题:设计一若干并发进程的进程调度程序一、实验目的无论是批处理系统、分时系统还是实时系统,用户进程数一般都大于处理机数,这将导致用户进程互相争夺处理机。

这就要求进程调度程序按一定的策略,动态地把处理及分配给处于就绪队列中的某一进程,以使之执行。

进程调度是处理机管理的核心内容。

本实验要求采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法编写和调试一个简单的进程调度程序。

通过本实验可以加深理解有关进程控制块、进程队列的概念。

并体会了优先数和先来先服务调度算法的具体实施办法。

二、实验要求用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解.三、实验内容进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法(将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列,并按照先来先服务的方式进行调度处理)。

每个进程有一个进程控制块(PCB)表示。

进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

进程的到达时间为进程输入的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。

就绪进程获得CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。

重复以上过程,直到所要进程都完成为止。

四、实验算法流程五、实验程序清单#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0struct pcb { /* 定义进程控制块PCB */char name[10];int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;char sort() /* 建立对进程进行优先级排列函数*/{PCB *first, *second;int insert=0;if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/ {p->link=ready;ready=p;}else /* 进程比较优先级,插入适当的位置中*/{first=ready;second=first->link;while(second!=NULL){if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/{ /*插入到当前进程前面*/p->link=second;first->link=p;second=NULL;insert=1;}else /* 插入进程优先数最低,则插入到队尾*/{first=first->link;second=second->link;}}if(insert==0) first->link=p;}}char input() /* 建立进程控制块函数*/{int i,num;//clrscr(); /*清屏*/printf("\n 请输入被调度的进程数目:");scanf("%d",&num);for(i=0;i<num;i++){p=getpch(PCB);printf("\n 输入进程名:");scanf("%s",p->name);printf("\n 输入进程优先数:");scanf("%d",&p->super);printf("\n 输入进程运行时间:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='w';p->link=NULL;sort(); /* 调用sort函数*/}}int space(){int l=0; PCB* pr=ready;while(pr!=NULL){l++;pr=pr->link;}return(l);}char disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n qname \t state \t super \t ndtime \t runtime \n");printf("|%s\t",pr->name);printf("|%c\t",pr->state);printf("|%d\t",pr->super);printf("|%d\t",pr->ntime);printf("|%d\t",pr->rtime);printf("\n");}char check() /* 建立进程查看函数*/{PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}char destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{printf("\n 进程[%s] 已完成.\n",p->name);free(p);}char running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ {(p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='w';sort(); /*调用sort函数*/}}main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("\n The execute number:%d \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n 按任一键继续......");ch=getchar();}printf("\n\n 进程已经完成.\n");ch=getchar();}六、运行结果分析结果分析:根据上述输入的三个进程的信息可以得到:优先级最高的是进程ping,所以最先调度进程ping,它的状态为运行态,需要执行的时间为5。

而当前就绪队列状态为:进程xu的优先级比较高,处于就绪队列前面,而进程gui的优先级是三者中最低的,所以处于就绪队列的最后。

而此时这两个进程的状态都为就绪态。

结果分析:当进程ping执行了一个时间片之后而它已占用CPU时间已达到所需要的运行时间,则将它的优先级减1之后,再将三个进程按优先级的大小排列,从中选择优先级大的进程进入运行状态,则该次进入运行态的是进程xu。

按照这种方式一直运行下去,直到:结果分析:当进程ping的CPU占用时间等于它需要的执行时间时,进程ping调度完成。

则这时进程调度中还有两个进程:进程gui和进程xu。

结果分析:当调度进程中只剩下进程gui和进程xu时,这时根据进程优先级的大小,进程gui将进入运行态。

结果分析:当进程xu完成调度时,进程调度程序中直剩下进程gui了,这时进程gui 将进入运行态,而当前就绪队列将为空。

结果分析:当进程gui的CPU占用时间等于所需要的执行时间时,进程gui调度完成,则这时进程调度中已经没有需要调度的进程了,则整个进程调度完成。

七、总结与体会该实验利用进程调度中的优先级算法调度进程,开始给每一个进程设定一个优先级数,对于优先级高的进程先调度,优先级低的进程后调度,在调度一个进程时,其他进程将处于就绪态,而正在被调度的进程应处于运行态。

一开始在做这个实验的时候,我感觉大脑一片空白,不知道该从哪里动笔。

后来根据书上的内容和从网上下载的资料,我慢慢地了解了大致的流程。

通过这次实验,首先加深了我对进程调度方法和功能的认识,其次让我更加深刻地理解了操作系统中进程调度中优先级调度的基本原理。

优先级调度算法只是进程调度算法的一种,我们还应依照书本去学习进程调度的其它算法,以便更好地了解进程调度。

相关文档
最新文档