进程调度实验报告
进程调度程序实验报告
一、实验目的通过本次实验,加深对进程调度原理和算法的理解,掌握进程调度程序的设计与实现方法。
实验要求我们使用高级编程语言编写一个简单的进程调度程序,实现不同调度算法的模拟,并通过实验验证算法的性能。
二、实验环境1. 操作系统:Windows 102. 编程语言:Java3. 开发工具:IntelliJ IDEA三、实验内容本次实验主要实现以下调度算法:1. 先来先服务(FCFS)2. 最短作业优先(SJF)3. 时间片轮转(RR)四、实验步骤1. 定义进程类(Process):```javapublic class Process {private String processName; // 进程名称private int arrivalTime; // 到达时间private int burstTime; // 运行时间private int waitingTime; // 等待时间private int turnaroundTime; // 周转时间// 构造函数public Process(String processName, int arrivalTime, int burstTime) {this.processName = processName;this.arrivalTime = arrivalTime;this.burstTime = burstTime;}// 省略getter和setter方法}```2. 定义调度器类(Scheduler):```javapublic class Scheduler {private List<Process> processes; // 进程列表private int currentTime; // 当前时间// 构造函数public Scheduler(List<Process> processes) {this.processes = processes;this.currentTime = 0;}// FCFS调度算法public void fcfs() {for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// SJF调度算法public void sjf() {processes.sort((p1, p2) -> p1.getBurstTime() -p2.getBurstTime());for (Process process : processes) {process.setWaitingTime(currentTime -process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime -process.getArrivalTime());}}// RR调度算法public void rr(int quantum) {List<Process> sortedProcesses = new ArrayList<>(processes);sortedProcesses.sort((p1, p2) -> p1.getArrivalTime() -p2.getArrivalTime());int timeSlice = quantum;for (Process process : sortedProcesses) {if (process.getBurstTime() > timeSlice) {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += timeSlice;process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(process.getBurstTime() - timeSlice);} else {process.setWaitingTime(currentTime - process.getArrivalTime());currentTime += process.getBurstTime();process.setTurnaroundTime(currentTime - process.getArrivalTime());process.setBurstTime(0);}}}}```3. 测试调度程序:```javapublic class Main {public static void main(String[] args) {List<Process> processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));Scheduler scheduler = new Scheduler(processes); System.out.println("FCFS调度结果:");scheduler.fcfs();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));processes.add(new Process("P4", 6, 4));System.out.println("SJF调度结果:");scheduler.sjf();for (Process process : processes) {System.out.println(process);}processes = new ArrayList<>();processes.add(new Process("P1", 0, 5));processes.add(new Process("P2", 1, 3));processes.add(new Process("P3", 4, 2));System.out.println("RR调度结果(时间片为2):");scheduler.rr(2);for (Process process : processes) {System.out.println(process);}}}```五、实验结果与分析通过实验,我们可以观察到以下结果:1. FCFS调度算法简单,但可能导致长作业等待时间过长。
实验一、进程调度实验报告
实验一、进程调度实验报告一、实验目的进程调度是操作系统中的核心功能之一,其目的是合理地分配 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分析:先来先服务调度算法简单直观,但对于短作业可能会造成较长的等待时间,导致平均等待时间和平均周转时间较长。
进程调度实验报告
进程调度实验报告一、实验目的。
本实验旨在通过对进程调度算法的模拟和实验,加深学生对进程调度原理的理解,掌握各种进程调度算法的特点和应用场景,提高学生的实际操作能力和分析问题的能力。
二、实验环境。
本次实验使用了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.先来先服务调度算法先来先服务调度算法是一种最简单的调度算法,该算法既可以用于作业调度,也可用于进程调度。
当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将他们调入内存,为它们分配资源、创建进程,然后放入就绪队列。
在进程调度中采用FCFS算法时,则每次调度是从就绪队列中选择一个最先进入该队列的进程,为之分配处理机,使之投入运行。
该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
FCFS算法比较有利于长作业(进程),2.短作业(进程)优先调度算法短作业(进程)优先调度算法SJ(P)F,是指对短作业或短进程优先调度的算法。
它们可以分别用于作业调度和进程调度。
短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行。
而短进程(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机再重新调度。
SJ(P)F调度算法能有效地降低作业(进程)的平均等待时间,提高系统吞吐量。
该算法对长作业不利,完全未考虑作业的紧迫程度。
3.时间片轮转算法在时间片轮转算法中,系统将所有的就绪进程按先来先服务的原则排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片。
当执行的时间片用完时,由一个计数器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片。
这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。
换言之,系统能在给定的时间内响应所有用户的请求。
实验进程调度的实验报告
一、实验目的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算法:优先调度运行时间最短的进程,能提高系统吞吐量,但可能导致进程饥饿。
进程调度 实验报告
进程调度实验报告进程调度实验报告概述:进程调度是操作系统中一个重要的组成部分,它负责决定在多个进程同时运行时,每个进程分配到的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算法能够有效减少平均等待时间。
进程的调度实验报告(3篇)
第1篇一、实验目的通过本次实验,加深对操作系统进程调度原理的理解,掌握先来先服务(FCFS)、时间片轮转(RR)和动态优先级(DP)三种常见调度算法的实现,并能够分析这些算法的优缺点,提高程序设计能力。
二、实验环境- 编程语言:C语言- 操作系统:Linux- 编译器:GCC三、实验内容本实验主要实现以下内容:1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、服务时间、优先级、状态等信息。
2. 实现三种调度算法:FCFS、RR和DP。
3. 创建一个进程队列,用于存储所有进程。
4. 实现调度函数,根据所选算法选择下一个执行的进程。
5. 模拟进程执行过程,打印进程执行状态和就绪队列。
四、实验步骤1. 定义PCB结构体:```ctypedef struct PCB {char processName[10];int arrivalTime;int serviceTime;int priority;int usedTime;int state; // 0: 等待,1: 运行,2: 完成} PCB;```2. 创建进程队列:```cPCB processes[MAX_PROCESSES]; // 假设最多有MAX_PROCESSES个进程int processCount = 0; // 实际进程数量```3. 实现三种调度算法:(1)FCFS调度算法:```cvoid fcfsScheduling() {int i, j;for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;if (processes[i].usedTime == processes[i].serviceTime) { processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); }for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(2)RR调度算法:```cvoid rrScheduling() {int i, j, quantum = 1; // 时间片for (i = 0; i < processCount; i++) {processes[i].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[i].processName); processes[i].usedTime++;processes[i].serviceTime--;if (processes[i].serviceTime <= 0) {processes[i].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[i].processName); } else {processes[i].arrivalTime++;}for (j = i + 1; j < processCount; j++) {processes[j].arrivalTime--;}}}```(3)DP调度算法:```cvoid dpScheduling() {int i, j, minPriority = MAX_PRIORITY;int minIndex = -1;for (i = 0; i < processCount; i++) {if (processes[i].arrivalTime <= 0 && processes[i].priority < minPriority) {minPriority = processes[i].priority;minIndex = i;}}if (minIndex != -1) {processes[minIndex].state = 1; // 设置为运行状态printf("正在运行进程:%s\n", processes[minIndex].processName);processes[minIndex].usedTime++;processes[minIndex].priority--;processes[minIndex].serviceTime--;if (processes[minIndex].serviceTime <= 0) {processes[minIndex].state = 2; // 设置为完成状态printf("进程:%s 完成\n", processes[minIndex].processName); }}}```4. 模拟进程执行过程:```cvoid simulateProcess() {printf("请选择调度算法(1:FCFS,2:RR,3:DP):");int choice;scanf("%d", &choice);switch (choice) {case 1:fcfsScheduling();break;case 2:rrScheduling();break;case 3:dpScheduling();break;default:printf("无效的调度算法选择。
进程调度实验报告答案(3篇)
第1篇一、实验目的通过本次实验,加深对操作系统进程调度过程的理解,掌握三种基本调度算法(先来先服务(FCFS)、时间片轮转、动态优先级调度)的原理和实现方法,并能够通过编程模拟进程调度过程,分析不同调度算法的性能特点。
二、实验环境1. 操作系统:Linux/Windows2. 编程语言:C/C++3. 开发环境:Visual Studio、Code::Blocks等三、实验内容1. 实现三种基本调度算法:FCFS、时间片轮转、动态优先级调度。
2. 编写代码模拟进程调度过程,包括进程创建、进程调度、进程运行、进程结束等环节。
3. 每次调度后,打印当前运行的进程、就绪队列以及所有进程的PCB信息。
4. 编写实验报告,描述数据结构、算法流程,展示实验结果,并总结心得。
四、实验步骤1. 定义进程控制块(PCB)结构体,包含进程名、到达时间、服务时间、已用时间、优先数、进程状态等信息。
2. 实现进程调度函数,根据所选调度算法进行进程调度。
3. 编写主函数,初始化进程信息,选择调度算法,并模拟进程调度过程。
4. 每次调度后,打印当前运行的进程、就绪队列以及所有进程的PCB信息。
5. 编写实验报告,描述数据结构、算法流程,展示实验结果,并总结心得。
五、实验结果与分析1. FCFS调度算法实验结果:按照进程到达时间依次调度,每个进程结束后,调度下一个进程。
分析:FCFS调度算法简单,易于实现,但可能会导致进程的响应时间较长,特别是当有大量进程到达时,后到达的进程可能会长时间等待。
2. 时间片轮转调度算法实验结果:每个进程完成一个时间片后,放弃处理机,转到就绪队列队尾。
分析:时间片轮转调度算法能够保证每个进程都能得到一定的运行时间,但可能会出现进程饥饿现象,即某些进程长时间得不到运行。
3. 动态优先级调度算法实验结果:每个进程完成一个时间片后,优先级减1,插入到就绪队列相关位置。
分析:动态优先级调度算法能够根据进程的运行情况动态调整优先级,使得优先级高的进程能够得到更多的运行时间,从而提高系统的响应速度。
进程调度模拟程序实验实验报告
进程调度模拟程序实验实验报告一、实验目的进程调度是操作系统的核心功能之一,它负责合理地分配 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。
进程调度实验报告
进程调度实验报告1. 引言进程调度是操作系统中一个重要的概念,它决定了各个进程在CPU上运行的次序和时间长度。
合理的进程调度能够提高系统的运行效率和响应速度。
本实验旨在研究不同的进程调度算法对系统性能的影响,并通过实验结果对比评估各个算法的优劣。
2. 实验过程2.1 实验环境搭建在进行实验之前,我们需要搭建一个适合的实验环境。
首先,选择一种操作系统作为实验的基础环境,在这个环境上进行后续步骤。
其次,选择一种编程语言或工具来实现不同的进程调度算法。
最后,准备一组测试用例,包含不同类型的进程和不同长度的时间片等。
2.2 实验步骤以下是实验的具体步骤: 1. 首先,选择合适的进程调度算法,如FCFS、SJF、RR 等。
2. 实现所选算法,并将其应用于测试用例上。
3. 模拟进程的运行过程,记录每个进程的等待时间、周转时间等指标。
4. 重复步骤1~3,使用不同的进程调度算法进行对比实验。
5. 分析实验结果,总结每种算法的优缺点。
2.3 实验数据分析根据实验得到的数据,我们可以对不同的进程调度算法进行分析。
可以从以下几个方面对算法的性能进行评估: - 平均等待时间:衡量了进程等待的时间长度,可以用来评估系统的效率和响应速度。
- 平均周转时间:衡量了进程从被提交到完成执行所经历的时间长度,可以用来评估系统的性能。
- CPU利用率:衡量了CPU 的利用效率,高CPU利用率意味着系统负载较高,可能导致响应速度下降。
- 算法复杂度:考虑到实际应用中所需的计算量,评估进程调度算法的复杂度。
3. 实验结果与讨论3.1 FCFS算法FCFS(First-Come, First-Serve)是最简单的进程调度算法,按照进程提交的顺序进行调度。
它的优点是简单易懂,适用于长作业时间的进程。
然而,它也存在着一些问题,如可能导致饥饿现象和平均周转时间较长。
3.2 SJF算法SJF(Shortest Job First)算法按照进程执行时间的长度进行调度,执行时间最短的进程先执行。
进程调度算法实验报告
实验报告实验一:进程调度算法一、实验目的1.利用高级语言实现三种不同及进程调度算法:短作业优先算法、时间片轮转调度算法和优先级调度算法。
2.通过实验理解有关进程控制块,进程队列等的概念。
二、实验原理各调度算法思想:1.先来先服务算法(FCFS):按照进程进入就绪队列的先后次序来分配CPU,一旦一个进程占有CPU,就一直运行下去,知道该进程完成工作,才释放CPU。
2.时间片轮转算法:系统将所有就绪进程按到达时间的先后次序排成一个队列,进程调度程序总是选择队列中的第一个进程执行,且仅能执行一个时间片,在使用完一个时间片后,即使进程并未完成其运行,也必须将CPU交给下一个进程;如果一个时间片未使用完就完成了该进程,则剩下的时间分配给下一个进程。
3.优先权调度算法;在创建进程时就确定优先权,确定之后在整个程序运行期间不再改变,根据优先级排列,系统会把CPU分配给优先权最高的进程。
三、实验步骤、数据记录及处理1、算法流程抽象数据类型的定义:PCB块结构体类型struct PCB{int name;int arrivetime; //到达时间int servicetime; //服务时间//int starttime[max]; //开始时间int finishtime; //完成/结束时间int turntime; //周转时间int average_turntime; //带权周转时间int sign; //标志进程是否完成int remain_time; //剩余时间int priority; //优先级}pcb[max];主程序的流程以及各程序模块之间的层次(调用)关系:主程序中从键盘得到进程的数量,创建PCB,调用layout()函数显示选择界面。
Layout()函数中选择相应的算法并调用相关函数如:FCFS()、time_segment();、Priority(),这三个函数分别实现先来先服务算法,时间片轮转算法和优先级算法,最后分别打印。
进程调度 实验报告
一、实验目的 多道程序设计中,经常是若干个进程同时处于就绪状态,必须依照某种策略来决定那
个进程优先占有处理机。因而引起进程调度。本实验模拟在单处理机情况下的处理机调度 问题,加深对进程调度的理解。 二、实验内容 1.优先权法、轮转法
简化假设 1)进程为计算型的(无 I/O) 2)进程状态:ready、running、finish 3)进程需要的 CPU 时间以时间片为单位确定 2.算法描述 1) 优先权法——动态优先权
/*******************优先权调度算法所需函数 *****************************************************/ struct process1*creatlist1(int n) {
srand((int)time(0)); struct process1 *first =new process1; first ->next=NULL; for (int i=0;i<n;i++) {
struct process1 *s; s =new process1; s->pcb =i; s-> privilege=random(20)+5; s->cpu=random(20)+1; insert1(first,s ); } return first; } void insert1(struct process1 *first,struct process1 *s) //插入节点 { struct process1 *p=search(first,s); s->next=p->next; p->next=s; //return; }
调度算法实验报告总结(3篇)
第1篇一、实验目的本次实验旨在通过模拟操作系统中的进程调度过程,加深对进程调度算法的理解。
实验中,我们重点研究了先来先服务(FCFS)、时间片轮转(RR)和动态优先级调度(DP)三种常见的调度算法。
通过编写C语言程序模拟这些算法的运行,我们能够直观地观察到不同调度策略对进程调度效果的影响。
二、实验内容1. 数据结构设计在实验中,我们定义了进程控制块(PCB)作为进程的抽象表示。
PCB包含以下信息:- 进程编号- 到达时间- 运行时间- 优先级- 状态(就绪、运行、阻塞、完成)为了方便调度,我们使用链表来存储就绪队列,以便于按照不同的调度策略进行操作。
2. 算法实现与模拟(1)先来先服务(FCFS)调度算法FCFS算法按照进程到达就绪队列的顺序进行调度。
在模拟过程中,我们首先将所有进程按照到达时间排序,然后依次将它们从就绪队列中取出并分配CPU资源。
(2)时间片轮转(RR)调度算法RR算法将CPU时间划分为固定的时间片,并按照进程到达就绪队列的顺序轮流分配CPU资源。
当一个进程的时间片用完时,它将被放入就绪队列的末尾,等待下一次调度。
(3)动态优先级调度(DP)算法DP算法根据进程的优先级进行调度。
在模拟过程中,我们为每个进程分配一个优先级,并按照优先级从高到低的顺序进行调度。
3. 输出调度结果在模拟结束后,我们输出每个进程的调度结果,包括:- 进程编号- 到达时间- 运行时间- 等待时间- 周转时间同时,我们还计算了平均周转时间、平均等待时间和平均带权周转时间等性能指标。
三、实验结果与分析1. FCFS调度算法FCFS算法简单易实现,但可能会导致进程的响应时间较长,尤其是在存在大量短作业的情况下。
此外,FCFS算法可能导致某些进程长时间得不到调度,造成饥饿现象。
2. 时间片轮转(RR)调度算法RR算法能够有效地降低进程的响应时间,并提高系统的吞吐量。
然而,RR算法在进程数量较多时,可能会导致调度开销较大。
进程调度实验报告源码
一、实验目的本次实验旨在通过模拟进程调度过程,加深对进程调度算法的理解,并掌握进程调度程序的设计与实现方法。
实验内容主要包括:创建进程、进程调度、进程执行、进程结束等。
二、实验环境操作系统:Linux编程语言:C/C++三、实验内容1. 进程调度算法本实验采用三种进程调度算法:FIFO(先进先出)、时间片轮转法、多级反馈队列调度算法。
2. 进程调度程序设计进程调度程序主要由以下部分组成:(1)进程控制块(PCB)PCB用于描述进程的基本信息,包括进程名、到达时间、需要运行时间、已运行时间、进程状态等。
(2)就绪队列就绪队列用于存储处于就绪状态的进程,按照进程的优先级或到达时间进行排序。
(3)进程调度函数进程调度函数负责从就绪队列中选择一个进程进行执行,并将CPU分配给该进程。
(4)进程执行函数进程执行函数负责模拟进程的执行过程,包括进程的创建、执行、结束等。
四、实验源码```c#include <stdio.h>#include <stdlib.h>#include <time.h>#define MAX_PROCESSES 10typedef struct PCB {int pid;int arrival_time;int need_time;int used_time;int priority;int state; // 0: 等待 1: 运行 2: 完成} PCB;PCB processes[MAX_PROCESSES];int process_count = 0;typedef struct Queue {PCB queue;int front;int rear;int size;} Queue;Queue ready_queue;void init_queue(Queue q) {q->queue = (PCB )malloc(sizeof(PCB) MAX_PROCESSES); q->front = q->rear = 0;q->size = 0;}void enqueue(Queue q, PCB p) {if (q->size == MAX_PROCESSES) {printf("Queue is full.\n");return;}q->queue[q->rear] = p;q->rear = (q->rear + 1) % MAX_PROCESSES; q->size++;}PCB dequeue(Queue q) {if (q->size == 0) {printf("Queue is empty.\n");return NULL;}PCB p = &q->queue[q->front];q->front = (q->front + 1) % MAX_PROCESSES; q->size--;return p;}int is_empty(Queue q) {return q->size == 0;}void print_queue(Queue q) {printf("Queue: ");for (int i = 0; i < q->size; i++) {PCB p = &q->queue[(q->front + i) % MAX_PROCESSES];printf("PID: %d, Arrival Time: %d, Need Time: %d, Used Time: %d, Priority: %d, State: %d\n",p->pid, p->arrival_time, p->need_time, p->used_time, p->priority, p->state);}}void init_processes() {for (int i = 0; i < MAX_PROCESSES; i++) {processes[i].pid = i;processes[i].arrival_time = rand() % 10;processes[i].need_time = rand() % 10 + 1;processes[i].used_time = 0;processes[i].priority = rand() % 3;processes[i].state = 0;}}void schedule() {int time = 0;while (process_count > 0) {for (int i = 0; i < process_count; i++) {PCB p = &processes[i];if (p->arrival_time == time) {enqueue(&ready_queue, p);p->state = 1;}}if (!is_empty(&ready_queue)) {PCB p = dequeue(&ready_queue);p->used_time++;printf("Process %d is running.\n", p->pid);if (p->used_time == p->need_time) {p->state = 2;printf("Process %d is finished.\n", p->pid); }}time++;}}int main() {srand(time(NULL));init_queue(&ready_queue);init_processes();process_count = rand() % MAX_PROCESSES + 1;schedule();print_queue(&ready_queue);return 0;}```五、实验结果与分析1. FIFO调度算法实验结果表明,FIFO调度算法按照进程的到达时间进行调度,可能导致短作业等待时间长,效率较低。
进程调度算法 实验报告
进程调度算法实验报告进程调度算法实验报告一、引言进程调度算法是操作系统中非常重要的一部分,它决定了系统中各个进程的执行顺序和时间分配。
在本次实验中,我们将研究和比较几种常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)、轮转法(RR)和优先级调度算法。
二、实验目的本次实验的目的是通过模拟不同的进程调度算法,观察它们在不同情况下的表现,并比较它们的优缺点,以便更好地理解和应用这些算法。
三、实验过程1. 实验环境准备我们使用C语言编写了一个简单的进程调度模拟程序,该程序可以模拟不同的进程调度算法,并输出每个进程的执行顺序和等待时间等信息。
2. 实验步骤(1)先来先服务(FCFS)算法FCFS算法是最简单的一种进程调度算法,它按照进程的到达顺序来执行。
我们通过模拟多个进程的到达时间和执行时间,观察它们的执行顺序和等待时间。
(2)最短作业优先(SJF)算法SJF算法是根据进程的执行时间来进行调度的,执行时间越短的进程优先执行。
我们通过模拟多个进程的执行时间,观察它们的执行顺序和等待时间。
(3)轮转法(RR)算法RR算法是一种时间片轮转的调度算法,每个进程被分配一个时间片,当时间片用完后,进程被挂起,等待下一次调度。
我们通过模拟不同的时间片大小,观察进程的执行顺序和等待时间。
(4)优先级调度算法优先级调度算法是根据进程的优先级来进行调度的,优先级高的进程优先执行。
我们通过模拟不同的进程优先级,观察进程的执行顺序和等待时间。
四、实验结果与分析1. 先来先服务(FCFS)算法当进程的执行时间相差不大时,FCFS算法的等待时间较长,因为后到达的进程需要等待前面的进程执行完毕。
但如果有一个进程的执行时间很长,其他进程的等待时间就会很短。
2. 最短作业优先(SJF)算法SJF算法能够保证最短执行时间的进程先执行,因此平均等待时间较短。
但如果有一个执行时间很长的进程到达,其他进程的等待时间就会变长。
进程调度实验报告
操作系统实验 报告实验项目: 进程调度学 院: 计算机学院专 业:班 级:学 号:姓 名:1. 实验目的在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理机数时,就必须依照某种策略来决定哪些进程优先占用处理机。
本实验模拟在单处理机情况下的进程调度,加深了解进程调度的工作。
2. 实验内容设计一个按时间片轮转法实现进程调度的程序。
(1)假定系统有五个进程,每一个进程用一个进程控制块PCB 来代表,进程控制块的格式为:其中,进程名——作为进程的标识,假设五个进程的进程名分别为Q 1,Q 2,Q 3,Q 4,Q 5。
指针——进程按顺序排成循环队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程的指针指出第一个进程的进程控制块首地址。
要求运行时间——假设进程需要运行的单位时间数。
已运行时间——假设进程已经运行的单位时间数,初始值为“0”。
状态——有两种状态,“就绪”和“结束”,初始状态都为“就绪”,用“R ”表示。
当一个进程运行结束后,它的状态为“结束”,用“E ”表示。
(2)每次运行所设计的进程调度程序前,为每个进程任意确定它的“要求运行时间”。
(3)把五个进程按顺序排成循环队列,用指针指出队列连接情况。
另用一标志单元记录轮到运行的进程。
例如,当前轮到Q 2执行,则有:进程名 指针 要求运行时间 已运行时间 状态标志单元(4)进程调度总是选择标志单元指示的进程运行。
由于本实验是模拟进程调度的功能,所以对被选中的进程并不实际的启动运行,而是执行“已运行时间+1”来模拟进程的一次运行,表示进程已经运行过一个单位的时间。
请注意:在实际的系统中,当一个进程被选中运行时,必须置上该进程可以运行的时间片值,以及恢复进程的现场,让它占有处理机运行,直到出现等待事件或运行满一个时间片。
在这时省去了这些工作,仅用“已运行时间+1”来表示进程已经运行满一个时间片。
(5)进程运行一次后,应把该进程的进程控制块中的指针值送到标志单元,以指示下一个轮到运行的进程。
操作系统进程调度模拟程序实验报告
操作系统进程调度模拟程序实验报告一、实验目的本次实验旨在通过编写一个模拟操作系统进程调度的程序,以加深对进程调度算法的理解。
二、实验内容1. 实现进程相关的数据结构:进程PCB(Process Control Block)。
2.实现进程的创建、撤销以及调度等操作函数。
3. 实现常见的进程调度算法:先来先服务(FCFS)、最短作业优先(SJF)、轮转调度(RR)、优先级调度(Priority)。
4.编写测试程序,验证实现的进程调度算法在不同场景下的表现。
三、实验过程及结果1.进程PCB的设计与实现进程PCB是进程的核心数据结构,用于存储和管理进程相关的信息,包括进程状态(就绪、运行、阻塞)、优先级、执行时间等。
2.进程的创建、撤销及调度函数的实现(1)进程创建函数:实现进程的创建,包括为其分配空间、初始化进程PCB等。
可以根据实际需求,设定进程的优先级、执行时间等属性。
(2)进程撤销函数:实现进程的撤销,包括释放其占用的资源、回收其使用的空间等。
(3)进程调度函数:根据不同的调度算法,实现进程的调度。
可以通过设置时间片大小、优先级设定等方式,实现不同调度算法的效果。
3.进程调度算法的设计与实现(1)先来先服务(FCFS)调度算法:按照进程到达的先后顺序,依次进行调度。
(2)最短作业优先(SJF)调度算法:根据进程的执行时间,选择执行时间最短的进程进行调度。
(3)轮转调度(RR)算法:按照时间片的大小进行调度,每个进程在一个时间片内执行,超过时间片后,暂停并进入等待队列,让其他进程执行。
(4)优先级调度(Priority)算法:根据进程的优先级,选择优先级最高的进程进行调度。
4.测试程序编写测试程序,模拟不同的进程到达顺序、执行时间和优先级等场景,验证不同调度算法的表现。
四、实验结果与分析通过测试程序的运行结果,观察不同调度算法的特点和效果。
可以得出以下结论:1.FCFS算法适用于进程到达时间差异较大的场景,保证了先到先服务。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
天津大学仁爱学院操作系统实验报告实验类型:必修实验日期:2014年4月18日实验名称:进程调度实验地点:二实验楼504学生姓名:李帅帅指导教师:张磊班级:计科一班计算机科学与技术系实验报告内容:1)实验目的用c语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解。
2)实验器材和设备硬件:二实验楼504计算机开发工具:Microsoft Visual C++ 6.03)实验任务本实验模拟单处理器系统的进程调度,加深对进程的概念及进程调度算法的理解。
用c语言编写和调试一个进程调度的算法程序,有一些简单的界面,能够运行,仿真操作系统中进程调度的原理和过程。
通过对调度算法的模拟,进一步理解进程的基本概念,加深对进程运行状态和进程调度4)实验原理无论是在批处理系统还是分时系统中,用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。
另外,系统进程也同样需要使用处理机。
这就要求进程调度程序按一定的策略,动态地把处理机分配给处于就绪队列中的某一个进程,以使之执行。
基本状态:1.等待态:等待某个事件的完成;2.就绪态:等待系统分配处理器以便运行;3.运行态:占有处理器正在运行。
运行态→等待态往往是由于等待外设,等待主存等资源分配或等待人工干预而引起的。
等待态→就绪态则是等待的条件已满足,只需分配到处理器后就能运行。
运行态→就绪态不是由于自身原因,而是由外界原因使运行状态的进程让出处理器,这时候就变成就绪态。
例如时间片用完,或有更高优先级的进程来抢占处理器等。
就绪态→运行态系统按某种策略选中就绪队列中的一个进程占用处理器,此时就变成了运行态5)实验过程描述a)打开Microsoft Visual C++ 6.0 ,创建工程。
b)根据要求用 c语言代码实现应用程序,并调试完成。
c)运行程序,根据提示输入相应的字符。
d)输入实验测试内容,并观察执行窗口显示的过程。
e)重复c、d过程,认真体会领悟。
6)实验代码// lss.cpp : Defines the entry point for the console application. //#include"stdafx.h"#include<stdlib.h>#include<conio.h>#include<iostream.h>#include<windows.h>#define P_NUM 3#define P_TIME 50enum state{ready,execute,block,finish};struct pcb{char name[4];int priority;int cputime;int needtime;int count;int round;state process;pcb * next;};pcb * get_process(){pcb *q;pcb *t;pcb *p;int i=0;t=(struct pcb *)malloc(sizeof(pcb));p=(struct pcb *)malloc(sizeof(pcb));cout<<"Input Name and Time"<<endl;while(i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name;cin>>q->needtime;q->cputime=0;q->priority=P_TIME-q->needtime;q->process=ready;q->next=NULL;if(i==0){p=q;t->next=q;}else{q->next=t->next;t=q;q=p;}i++;}return p;}void display(pcb * p){cout<<"name"<<" "<<"cputime"<<"needtime"<<" "<<"priority"<<" "<<"state"<<endl;while(p){cout<<p->name;cout<<" ";cout<<p->cputime;cout<<" ";cout<<p->needtime;cout<<" ";cout<<p->priority;cout<<" ";switch(p->process){case ready:cout<<"ready"<<endl;break;case execute:cout<<"execute"<<endl;break;case block:cout<<"block"<<endl;break;case finish:cout<<"finish"<<endl;break;}p=p->next;}}int process_finish(pcb *q){int b1=1;while(b1&&q){b1=b1&&q->needtime==0;q=q->next;}return b1;}void cpuexe(pcb *q){pcb *t=q;int tp=0;while(q){if(q->process!=finish){q->process=ready;if(q->needtime==0){q->process=finish;}}if(tp<q->priority&&q->process!=finish){tp=q->priority;t=q;}q=q->next;}if(t->needtime!=0){t->priority-=3;t->needtime--;t->process=execute;t->cputime++;}}void priority_cal(){pcb * p;system("cls");p=get_process();int cpu=0;system("cls");while(!process_finish(p)){cpu++;cout<<"cuptime:"<<cpu<<endl;cpuexe(p);display(p);Sleep(1000);}printf("All processes have finished,press any key to exit");getch();}void display_menu(){cout<<"\nCHOOSE THE ALGORITHM:"<<endl;cout<<"1 PRIORITY"<<endl;cout<<"2 roundrobin"<<endl;cout<<"3 EXIT"<<endl;}//显示调度算法菜单,可供用户选择优先权调度算法和时间轮转调度算法pcb *get_process_round(){pcb *q;pcb *t;pcb *p;int i=0;t=(struct pcb *)malloc(sizeof(pcb));p=(struct pcb *)malloc(sizeof(pcb));cout<<"input name and time"<<endl;while(i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name;cin>>q->needtime;q->cputime=0;q->round=0;q->count=0;q->process=ready;q->next=NULL;if(i==0){p=q;t->next=q;}else{q->next=t->next;t=q; q=p;}i++;}return p;}void cpu_round(pcb *q){q->cputime+=2;q->needtime-=2;if(q->needtime<0){q->needtime=0;}q->count++;q->round++;q->process=execute;}pcb * get_next(pcb * k,pcb * head){pcb * t;t=k;do{t=t->next;}while(t&&t->process==finish);if(t==NULL){t=head;while(t->next!=k&&t->process==finish)}}return t;}void set_state(pcb *p){while(p){if(p->needtime==0){p->process=finish;//如果所需执行时间为0,则设置运行状态为结束}if(p->process==execute){p->process=ready;//如果未执行状态则设置为就绪}p->next;}}//设置队列中进程执行状态void display_round(pcb *p){cout<<"NAME"<<" "<<"CPUTIME"<<" "<<"NEEDTIME"<<" "<<"COUNT"<<" "<<"ROUND"<<" "<<"STATE"<<endl;while(p){cout<<p->name;cout<<" ";cout<<p->cputime;cout<<" ";cout<<p->needtime;cout<<" ";cout<<p->count;cout<<" ";cout<<p->round;cout<<" ";switch(p->process){case ready:cout<<"ready"<<endl;break;case execute:cout<<"execute"<<endl;break;case finish:cout<<"finish"<<endl;break;p=p->next;}}//时间片轮转调度算法输出调度信息void round_cal(){pcb * p;pcb * r;system("cls");p=get_process_round();int cpu=0;system("cls");r=p;while(!process_finish(p)){cpu+=2;cpu_round(r);r=get_next(r,p);cout<<"cpu"<<cpu<<endl;display_round(p);set_state(p);Sleep(1000);}}int main(int argc,char* argv[]){display_menu();int k;scanf("%d",&k);while(1){switch(k){case 1:priority_cal();break;case 2:round_cal();break;case 3:return 0;}display_menu();scanf("%d",&k);}printf("\n本调度算法成功结束!\n;");return 0;}7)实验结果截图天津大学仁爱学院——计算机科学与技术系——李帅帅8)对实验的总结本次实验,任务是用c语言代码实现进程调度模拟系统,从而观察进程的运行过程及加深对进程的了解。