实验2-处理机调度
武汉理工大学操作系统处理机调度实验报告【范本模板】
学生学号Xxx 实验课成绩学生实验报告书实验课程名称操作系统C开课学院计算机科学与技术学院指导教师姓名xxx学生姓名xxx学生专业班级xxxx2016—- 2017学年第 1 学期实验课程名称：操作系统C③用while进行循环控制选择不同的算法2.数据结构的设计记录不同作业信息的结构体数组。
struct node job[100]；记录作业/进程详细信息的结构体typedef struct node {string name;double submit;//提交时间double start；//开始时间double run;//运行时间double end;//完成时间double Ti;//周转时间double Wi;//带权周转时间double H；//响应比int priority;//优先级｝*work；3。
核心算法设计（1）按提交时间进行排序的算法Input:work p //指向作业的指针int N //作业的个数Process:void sort (work p,int N){for（int i=0；i<N；i++)｛（2)三、主要仪器设备及耗材1．安装了Windows XP或Windows 7或其它版本的Windows操作系统的PC机1台2．P C机系统上安装了Microsoft Visual Studio 2010开发环境第二部分：实验过程和结果（可加页）一、实现说明在VS2010中创建一个算法调度项目，对于不同的调度算法分别进行算法设计，对于算法的设计要特别注意作业的提交情况,实验中存储作业信息的结构体是相同的，采用结构体数组保存全部的作业，每次通过对结构体数组进行遍历计算不同算法需要的信息，最后在主函数中用while循环和switch语句进行各个调度算法的选择,最后经过不断的调试和运行,实现四个调度算法分别是先来先服务、短进程优先、优先级和最高响应比优先。
二、调试说明（调试手段、过程及结果分析）调试过程出现的问题比较多,第一个问题是对于不同作业提交的先后顺序要加以考虑，对于作业提交时间进行排序选择,必须选择提交时间在上一个作业结束时间之前的作业进行短进程，优先级,最高响应比排序，经过排序选择后，出现的问题是在进行作业调度完，有的作业出现了负的结束时间,经过调试分析，发现不能直接用上一个作业的结束时间直接当做下一个作业的开始时间，每次进行作业调度前要进行提交时间与上一个作业结束时间的比较，如果在作业提交前,下一个作业还没有提交，那么在下一个作业的开始时间就是它的提交时间。
操作系统实验之处理机调度实验报告
操作系统实验之处理机调度实验报告一、实验目的处理机调度是操作系统中的核心功能之一，本次实验的主要目的是通过模拟不同的处理机调度算法，深入理解操作系统对处理机资源的分配和管理策略，比较不同调度算法的性能差异，并观察它们在不同负载情况下的表现。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 Python 38。
实验中使用了 Python 的相关库，如`numpy`、｀matplotlib`等，用于数据生成、计算和图形绘制。
三、实验原理1、先来先服务（FCFS）调度算法先来先服务算法按照作业到达的先后顺序进行调度。
先到达的作业先被服务，直到完成或阻塞，然后再处理下一个到达的作业。
2、短作业优先（SJF）调度算法短作业优先算法选择预计运行时间最短的作业先执行。
这种算法可以有效地减少作业的平均等待时间，但可能导致长作业长时间等待。
3、时间片轮转（RR）调度算法时间片轮转算法将处理机的时间分成固定长度的时间片，每个作业轮流获得一个时间片的处理时间。
当时间片用完后，如果作业还未完成，则将其放入就绪队列的末尾等待下一轮调度。
4、优先级调度算法优先级调度算法为每个作业分配一个优先级，优先级高的作业先被执行。
优先级可以根据作业的性质、紧急程度等因素来确定。
四、实验内容与步骤1、数据生成首先，生成一组模拟的作业，包括作业的到达时间、预计运行时间和优先级等信息。
为了使实验结果更具代表性，生成了不同规模和特征的作业集合。
2、算法实现分别实现了先来先服务、短作业优先、时间片轮转和优先级调度这四种算法。
在实现过程中，严格按照算法的定义和规则进行处理机的分配和调度。
3、性能评估指标定义了以下性能评估指标来比较不同调度算法的效果：平均等待时间：作业在就绪队列中的等待时间的平均值。
平均周转时间：作业从到达系统到完成的时间间隔的平均值。
系统吞吐量：单位时间内完成的作业数量。
4、实验结果分析对每种调度算法进行多次实验，使用不同的作业集合，并记录相应的性能指标数据。
实验二--单处理器系统的进程调度
实验二–单处理器系统的进程调度
简介
在操作系统中，进程调度是非常重要的一项工作。
进程调度负责将CPU分配
给各个进程，使得每个进程都能够有机会占用CPU资源。
在单处理器系统中，CPU只有一个，因此进程调度是非常重要的。
本次实验将会探究单处理器系统的进程调度，了解各种进程调度算法的实现和
比较，利用模拟操作系统的实验平台进行实验。
实验目的
1.了解进程调度的基本概念和实现方法；
2.学习多种进程调度算法，并比较其优缺点；
3.熟悉模拟操作系统的实验环境，学习如何将算法实现到具体的系统中。
实验内容
进程调度的基本概念
进程调度是指将CPU资源分配给各个进程的过程。
在单处理器系统中，当有
多个进程需要使用CPU时，操作系统需要进行进程调度，使得每个进程都能够得
到CPU资源。
在进程调度中，需要考虑各个进程的优先级、进程的状态和进程的等待时间等
因素。
根据不同的调度算法，可以根据这些因素来确定哪个进程应该先占用CPU。
进程调度算法比较
常见的进程调度算法包括：
1.先来先服务算法（FCFS）
2.短作业优先算法（SJF）
3.优先级调度算法
4.时间片轮转算法（RR）
下面将对这些算法进行比较和介绍。
先来先服务算法（FCFS）
先来先服务算法是最简单的一种进程调度算法。
该算法将按照进程的到达时间
的先后顺序进行调度，先到达的进程先得到CPU资源。
这种算法的优点是实现简单，适用于短作业和计算密集型进程。
缺点是无法充分利用CPU资源，导致长作业需要等待较长时间才能被调度，容易产生。
处理机调度实验报告
处理机调度实验报告处理机调度实验报告一、引言处理机调度是计算机操作系统中一个重要的概念，它涉及到如何合理地分配处理机资源以提高系统的运行效率。
本文将针对处理机调度进行实验，探讨不同调度算法对系统性能的影响。
二、实验目的本实验的目的是通过模拟不同的处理机调度算法，比较它们在不同负载下的性能表现，进而分析其优缺点，为实际操作系统的调度算法选择提供参考。
三、实验方法1. 实验环境本实验使用了一台配置较高的计算机作为实验环境，操作系统为Linux，处理器为Intel Core i7，内存为8GB。
2. 实验设置为了模拟不同的负载情况，我们使用了三个不同的测试程序：程序A、程序B和程序C。
程序A是一个计算密集型任务，程序B是一个I/O密集型任务，程序C是一个混合型任务。
3. 实验步骤首先，我们分别运行程序A、程序B和程序C，并记录它们的运行时间。
然后，我们使用不同的调度算法来调度这些任务，并记录它们的运行时间和系统资源利用率。
四、实验结果与分析1. 调度算法1：先来先服务（First-Come, First-Served，FCFS）FCFS算法按照任务到达的先后顺序进行调度，即先到先服务。
实验结果显示，在计算密集型任务下，FCFS算法表现较好，但在I/O密集型任务和混合型任务下，其性能明显下降。
这是因为在FCFS算法中，任务的执行顺序是固定的，无法根据任务的特性进行灵活调度。
2. 调度算法2：最短作业优先（Shortest Job First，SJF）SJF算法根据任务的执行时间进行调度，即执行时间最短的任务先执行。
实验结果显示，在计算密集型任务和混合型任务下，SJF算法表现较好，但在I/O密集型任务下，其性能较差。
这是因为在I/O密集型任务中，任务的执行时间不仅与计算量有关，还与I/O操作的耗时有关，因此SJF算法无法有效地进行调度。
3. 调度算法3：时间片轮转（Round Robin，RR）RR算法将处理机的运行时间划分为若干个时间片，每个任务在一个时间片内执行一定的时间，然后切换到下一个任务。
用C语言模拟Linux操作系统下处理机调度实验报告
实验二：处理机调度一、实验目的：1、了解Linux下Emacs编辑器的使用方法，掌握各种常用的键盘操作命令；2、理解并掌握处理机调度算法。
二、实验内容及要求：在采用多道系统的设计程序中，往往有若干进程同时处于就绪状态。
当就绪状态进程数大于处理机数时，就必须按照某种策略来决定哪些进程优先占用处理机。
本实验模拟在单处理机情况下处理机调度。
1、优先调度算法实现处理机的调度：设计思路：1每个进程用一个进程控制块PCB来代表，进程控制块包括进程名(进程的标识、指针(按优先数的大小把进程连成队列，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针为"0"、要求运行时间、优先数、状态(就绪、结束；2每次运行处理机调度程序前，为每个进程确定它的"优先数"和"要求运行时间"；3把给定的进程按优先数的大小连成队列，用一单元指出队首进程；4每模拟执行一次进程，优先数减一，要求运行时间减一；5如果要求运行的时间>=0，再将它加入队列（按优先数的大小插入，重置队首标志）；如果要求运行的时间=0，那么把它的状态修改为结束，且推出队列；6若就绪队列不为空，重复上述，直到所有的进程都结束；7程序有显示和打印语句，每次运行后显示变化。
2、按时间片轮转法实现处理机调度：设计思路：1每个进程用一个进程控制块PCB来代表，进程控制块包括进程名(进程的标识、指针(把进程连成循环队列，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针指出第一个进程的进程控制块首地址、已运行时间、状态(就绪、结束；2每次运行处理机调度程序前，为每个进程确定它的"要求运行时间"；3用指针把给定的进程按顺序排成循环队列，用另一标志单元记录轮到的进程；4每模拟运行一次进程，已运行时间加一；5进程运行一次后，把该进程控制块的指针值送到标志单元，以指示下一个轮到的进程。
处理机调度实验报告1
设置多个就绪队列，各个队列优先级逐个降低，各个队列时间片逐个增加，优先级越高的队列执行时间片就越短，一般时间片按倍增规则，例如，第二队列的时间片要比第一个队列的时间片长一倍，……，第i+1个队列的时间片要比第i个队列的时间片长一倍，整合了时间片、FCFS、优先级三种机制。
三．实验过程及内容：(对程序代码进行说明和分析，越详细越好，代码排版要整齐，可读性要高)
time+=pcbdata1[t_ready[0]].time_need;
j=time-pcbdata1[t_ready[0]].time_start;
k=(float)j/pcbdata1[t_ready[0]].time_need;
t_order[0]=0;
printf("完成时间--%d,周转时间--%d,带权周转时间--%.1f\n",time,j,k);
}
}
//**************调度函数
void FCFS()
{
int i,j,temp;
double k;
for(i=0;i<num;i++)
{order[i]=pcbdata[i].time_start;
ready[i]=i;
}
for(i=0;i<num;i++) //按到达时间排序
for(j=i+1;j<num;j++)
t_ready[i]=ready[i];
}
time=order[0];
for(l=0;l<num1;l++){
//判断到达的进程数，用temp_num存放
for(i=0;i<num&&pcbdata1[ready[i]].time_start<=time;i++)
操作系统实验二进程调度
实验二：进程调度一、目的要求：用C或C++语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．二、进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
每个进程有一个进程控制块（ PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
三调度算法的流程图如下 :四、程序代码：#include<iostream>using namespace std;#define MAX 10struct task_struct{char name[10]; /*进程名称*/ int number; /*进程编号*/ float come_time; /*到达时间*/float run_begin_time; /*开始运行时间*/ float run_time; /*运行时间*/float run_end_time; /*运行结束时间*/ int priority; /*优先级*/int order; /*运行次序*/int run_flag; /*调度标志*/}tasks[MAX];int counter; /*实际进程个数*/int fcfs(); /*先来先服务*/int ps(); /*优先级调度*/int sjf(); /*短作业优先*/int hrrn(); /*响应比高优先*/int pinput(); /*进程参数输入*/int poutput(); /*调度结果输出*/void main(){int option;pinput();printf("请选择调度算法（0~4）:\n");printf("1.先来先服务\n");printf("2.优先级调度\n");printf(" 3.短作业优先\n");printf(" 4.响应比高优先\n");printf(" 0.退出\n");scanf("%d",&option);switch (option){ case 0:printf("运行结束。
处理机模拟调度课程设计
处理机模拟调度课程设计一、课程目标知识目标：1. 让学生理解处理机调度的基本概念，掌握常见的调度算法及其原理。
2. 使学生掌握模拟调度过程中的各个阶段，了解其相互关系和影响。
3. 帮助学生掌握分析调度算法性能的方法，能够从理论上评估算法的优劣。
技能目标：1. 培养学生运用所学调度算法进行模拟调度的实际操作能力。
2. 培养学生运用编程语言实现调度算法，解决实际调度问题的能力。
3. 提高学生分析调度算法性能，提出改进措施的能力。
情感态度价值观目标：1. 培养学生对处理机调度研究的兴趣，激发学生的学习热情。
2. 培养学生的团队合作意识，提高学生在团队中的沟通与协作能力。
3. 培养学生严谨的科学态度，树立正确的价值观，认识到技术发展对社会进步的重要性。
本课程针对高中年级学生，课程性质为理论与实践相结合。
在分析课程性质、学生特点和教学要求的基础上，将课程目标分解为具体的学习成果，以便后续的教学设计和评估。
通过本课程的学习，学生将能够掌握处理机调度相关知识，具备解决实际调度问题的能力，并形成积极的情感态度价值观。
二、教学内容本课程教学内容主要包括以下几部分：1. 处理机调度基本概念：介绍处理机调度的定义、作用和分类，以及调度过程中涉及的关键术语。
2. 常见调度算法：讲解先来先服务（FCFS）、短作业优先（SJF）、优先级调度、时间片轮转等调度算法的原理和实现。
3. 调度算法性能分析：分析各种调度算法的性能指标，如平均等待时间、平均周转时间、响应时间等。
4. 模拟调度实验：设计实验，使学生通过实际操作了解调度算法的执行过程，学会使用编程语言实现调度算法。
5. 教学案例分析与讨论：分析实际调度案例，引导学生运用所学知识解决实际问题，并提出改进措施。
教学内容安排如下：第一课时：处理机调度基本概念第二课时：先来先服务（FCFS）调度算法第三课时：短作业优先（SJF）调度算法第四课时：优先级调度和时间片轮转调度算法第五课时：调度算法性能分析第六课时：模拟调度实验第七课时：教学案例分析与讨论教学内容与课本紧密关联，按照教学大纲逐步推进，确保学生能够系统地掌握处理机调度的相关知识。
操作系统单处理机系统的进程调度
操作系统单处理机系统的进程调度第一篇：操作系统单处理机系统的进程调度一.实验内容描述1.目的（1）了解Windows内存管理器（2）理解Windows的地址过程2.内容任意给出一个虚拟地址，通过WinDbg观察相关数据并找到其物理地址二.理论分析Windows采用页式虚拟存储管理技术管理内存，页面是硬件级别上的最小保护单位 1.Windows内存管理器Windows的内存管理主要由Windows执行体中的虚存管理程序负责，并由环境子系统负责，并由环境子系统负责与具体API相关的一些用户态特性的实现。
虚存管理程序是Windows中负责内存管理的那些子程序和数据结构的集合内存管理器的主要任务是：地址变换：将一个进程的虚拟地址空间转译为物理内存地址交换：当内存不足时，将内存中的有些内容转移到磁盘上，并且以后还要再次将这些内容读回2.Windows内存管理策略Windows采用页式虚拟存储管理技术管理内存，页面是硬件级别上最小的保护单位。
根据硬件的体系结构不同，页面尺寸被分为两种，大页面和小页面。
X86系统下小页面为4KB，大页面为4MB。
大页面的优点是：当引用同一页面内其他数据时，地址转移的速度会很快。
不过使用大页面通常要较大的内存空间，而且必须用一个单独的保护项来映射，因此可能会造成出现错误而不引发内存访问违例的情况。
通常PC机都为小页面 3.Windows虚拟地址空间布局 x86结构下的布局方式：默认情况下，32位Windows系统中每个用户进程可以占有2GB 的私有地址空间。
操作系统占有另外的2GB 2GB用户的进程地址空间布局如表：2GB的系统地址空间布局如同：3.虚拟地址转译地址转译是指将进程的虚拟地址空间映射到实际物理页面的过程。
x86系统中地址转译过程如图：关键数据结构如下：页目录：每个进程都有一个页目录，它是内存管理器为了映射进程中所有的页表位置而创建的一个页面。
进程也目录的地址被保存在内核进程快KPROCESS中，在x86系统上，它被映射到虚拟地址0xC0300000，当一个进程正在执行时，CPU可以通过寄存器CR3知道该进程页目录的位置。
处理器调度实验报告
一、实验目的1. 理解处理器调度的基本概念和原理；2. 掌握常用的处理器调度算法，如先来先服务（FCFS）、短作业优先（SJF）、优先级调度等；3. 分析不同调度算法的性能指标，如平均周转时间、平均带权周转时间等；4. 通过实验，提高实际操作和编程能力。
二、实验原理处理器调度是操作系统中的一个重要组成部分，其主要任务是合理分配处理器资源，使系统中的多个进程高效、有序地运行。
常见的处理器调度算法有以下几种：1. 先来先服务（FCFS）：按照进程到达就绪队列的顺序进行调度，先到先服务；2. 短作业优先（SJF）：优先选择运行时间最短的进程执行；3. 优先级调度：根据进程的优先级进行调度，优先级高的进程先执行；4. 时间片轮转（RR）：将每个进程分配一个时间片，按照时间片轮转的方式调度进程。
三、实验内容1. 实验环境：Windows操作系统，Python编程语言；2. 实验工具：Python编程环境，如PyCharm、Spyder等；3. 实验步骤：（1）设计一个进程类，包含进程名、到达时间、运行时间、优先级等属性；（2）编写调度算法，实现FCFS、SJF、优先级调度和时间片轮转算法；（3）模拟进程执行过程，记录各个进程的执行时间、等待时间、周转时间等性能指标；（4）分析不同调度算法的性能，比较其优劣。
四、实验结果与分析1. FCFS调度算法实验结果：平均周转时间为20，平均带权周转时间为1.25。
分析：FCFS调度算法简单易实现，但可能导致进程响应时间长，不利于实时性要求高的系统。
2. SJF调度算法实验结果：平均周转时间为16，平均带权周转时间为1.2。
分析：SJF调度算法可以缩短平均周转时间，提高系统性能，但可能使长作业长时间等待，影响公平性。
3. 优先级调度算法实验结果：平均周转时间为18，平均带权周转时间为1.3。
分析：优先级调度算法可以根据进程的优先级进行调度，提高系统响应速度，但可能导致低优先级进程长时间等待。
实验二：进程调度
实验二 进程调度一、 实验目的多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。
因而引起进程调度。
本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。
二、 实验要求1． 设计进程调度算法，进程数不定2． 包含几种调度算法，并加以实现3． 输出进程的调度过程——进程的状态、链表等。
三、 参考例1．题目——优先权法、轮转法简化假设1） 进程为计算型的（无I/O ）2） 进程状态：ready 、running 、finish3） 进程需要的CPU 时间以时间片为单位确定2．算法描述1） 优先权法——动态优先权当前运行进程用完时间片后，其优先权减去一个常数。
2） 轮转法四、 实验流程图 开始 键盘输入进程数n ，和调度方法的选择 优先权法？ 轮转法产生n 个进程，对每个进程产生一个PCB ，并用随机数产生进程的优先权及进程所需的CPU 时间按优先权大小，把n 个进程拉成一个就绪队列撤销进程就绪队列为空？结束 N YY注意：1．产生的各种随机数的取值范围加以限制，如所需的CPU 时间限制在1~20之间。
2．进程数n 不要太大通常取4~8个3．使用动态数据结构4．独立编程5．至少三种调度算法6．若有可能请在图形方式下，将PCB 的调度用图形成动画显示。
五．实验过程：要求：读懂下面给出的程序，然后将其改写成由用户选择调度方式，例如：1、 FIFO2、 优先权调度3、 时间片轮转4、 退出对于每一种调度算法，由用户确定进程数，数据可以从文件读取，也可由用户手动输入。
（1）输入：进程流文件（1.txt ），其中存储的是一系列要执行的进程， 每个作业包括四个数据项：进程名 进程状态(1就绪 2等待 3运行) 所需时间 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5进程4 2 19 1 产生n需的时间片数，已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0？ 撤销该进程就绪队列为空吗？ =轮转时间片数？NY YY 结束 N进程5 3 8 7输出: 进程执行流等待时间，平均等待时间本程序包括:FIFO算法，优先数调度算法，时间片轮转调度算法（2）程序代码#include<stdio.h>#include<string.h>#include<iostream.h>const int block_time=10; //定义时间片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time;}pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<MAXPCB;i++){strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status,&pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;cout<<"进程名进程状态所需时间优先数"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" \t"<<pcbs[i].status<<" \t"<<pcbs[i].time<<" \t"<<pcbs[i].privilege<<endl;}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<MAXPCB;i++){pcbs[i].finished=0;pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j; int total;//输出FIFO算法执行流cout<<endl<<"*****************************************************"<<endl;cout<<"FIFO算法执行流:"<<endl; cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;for(j=i+1;j<quantity;j++){pcbs[j].wait_time+=pcbs[i].time;}}total=0;for(i=0;i<quantity;i++){total+=pcbs[i].wait_time;}cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++){current_privilege=1000;for(j=0;j<quantity;j++){if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privilege)){p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"***********************************************************"<< endl;cout<<"优先数调度执行流:"<<endl;cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;}total=0;for(i=0;i<quantity;i++){total+=pcbs[i].wait_time;}cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl; }//时间片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++){if(pcbs[i].finished==0){number++; j=i;}}if(number==1){queue[total]=j;total++;pcbs[j].finished=1;}if(number>1){for(i=0;i<quantity;i++){if(pcbs[i].finished==0){flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;}if(queue[total-1]==queue[total-2]){total--;}cout<<endl<<"*******************************************************"<<endl;cout<<"时间片轮转调度执行流:"<<endl;for(i=0;i<total;i++){cout<<pcbs[queue[i]].name<<" ";cout<<endl;}}//显示void version(){cout<<" /********************* 进程调度********************/";cout<<endl<<endl;}//主函数void main(){int flag;version();initial();flag=readData();if(flag==1){FIFO();init();privilege();init();timer();}}（3）运行结果：输入进程流文件名1.txt即可得出以下输出结果：。
处理机的调度课程设计
处理机的调度课程设计一、教学目标本节课的教学目标是让学生掌握处理机的调度原理和方法，理解调度算法的基本思想和实现方式，能够分析调度算法的性能和适用场景。
具体包括以下三个方面的目标：1.知识目标：（1）了解处理机调度的基本概念、作用和分类；（2）掌握常用调度算法（如FCFS、SJF、HRRN等）的基本原理和实现方式；（3）理解调度算法的设计思想和评价指标。
2.技能目标：（1）能够运用调度算法分析实际问题，设计简单的调度策略；（2）具备调试和优化调度算法的能力；（3）会使用相关工具和软件进行调度算法的实现和性能分析。
3.情感态度价值观目标：（1）培养学生对计算机系统运行效率的重视；（2）培养学生勇于探索、创新的精神；（3）培养学生团队协作、沟通交流的能力。
二、教学内容本节课的教学内容主要包括以下几个部分：1.处理机调度概述：介绍处理机调度的基本概念、作用和分类；2.常用调度算法：详细讲解FCFS、SJF、HRRN等调度算法的原理和实现方式；3.调度算法的设计思想和评价指标：分析调度算法的设计思路，介绍调度算法的评价指标；4.调度算法的应用和实践：探讨调度算法在实际应用中的案例，教授如何设计和优化调度策略。
三、教学方法为了达到本节课的教学目标，我们将采用以下教学方法：1.讲授法：讲解处理机调度的基本概念、原理和算法；2.讨论法：学生讨论调度算法的设计思想和应用场景；3.案例分析法：分析实际案例，让学生了解调度算法在实际应用中的作用；4.实验法：引导学生动手实践，调试和优化调度算法。
四、教学资源为了支持本节课的教学内容和教学方法的实施，我们将准备以下教学资源：1.教材：选用权威、实用的教材，如《计算机操作系统》；2.参考书：提供相关领域的参考书籍，以便学生深入理解调度算法；3.多媒体资料：制作精美的PPT，生动展示调度算法的原理和应用；4.实验设备：准备相应的实验设备，如计算机、网络设备等，让学生动手实践。
计算机操作系统实验---进程调度
操作系统实验报告--进程调度计科02-8 王长青05年4月17日计算机操作系统实验——进程调度一．实验目的进程调度是处理机管理的核心内容。
通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数调度算法的具体实施办法。
二．程序功能本程序使用VC++编译调试，用于实现进程优先数调度的模拟。
主要包含三个模块：1、主界面：用于显示进程调度的过程。
2、数据录入模块：用于获取进程的初始值，其中有三种获取方式，手动输入方式、随即生成方式和从文件中读去数据的方式。
当用户在主窗口中点击“开始”菜单项时即可打开数据录入对话框，用户通过这三种方式之一均可完成数据的录入。
3、进程控制模块：主要实现创建新的进程，就绪队列的管理，完成队列的管理，进程的调度。
三．实验原理（1）本程序采用优先数调度算法对进程进行调度，每个进程可有三个状态，即：就绪状态，运行状态，完成状态。
并假设初始状态为就绪状态。
这三种状态的转换情况如右图：（2）为了便于处理，程序中的某进程运行时间以时间片为单位计算。
各进程的优先数以及进程需运行的时间片数的初始值均由用户给定（通过数据录入模块完成）。
（3）程序通过设置一个定时器来实现时间片的轮转，时间片的大小是1秒，在定时器消息的响应函数中从用户录入的数据中读取一个创建进程，将其加入到就绪队列中，然后进行调度和执行。
在调度函数中，对于遇到优先数一致的情况，采用FIFO策略解决。
（4）在优先数算法中，进程每执行一次，优先数减3，进程还需要运行的时间数减1。
四．详细设计（1）设计进程控制块PCB结构：struct PCB{ int pid; //进程号int pri; //进程优先数int time; //进程所需运行时间int status; // 进程状态 0就绪，1 执行，-1完成};（2）将进程的各种操作封装在类CProMoni中，该类的定义如下：class CProMoni{public:CProMoni();virtual ~CProMoni();void InsertRQ(PCB* p); //将p所指的进程插入到就绪队列中void InsertFQ(PCB* p); //将p所指的进程插入到完成队列中void ProSchedule(); //进程调度函数void ProRun(); //运行函数void Display(CDC* pDC); //以表格形式输出运行过程bool GetFinishFlag();bool OpenLogFile(); //打开日志文件void CloseLogFile(); //关闭日志文件bool WriteLogToFile(); //向日志文件中写入数据private:PCB *m_pRunning; //指向当前运行的进程CPtrList m_readyList; //就绪队列CPtrList m_finishList; //完成队列bool m_finish; //完成标志CString m_LogFileName; //日志文件名CStdioFile m_LogFile; //日志文件public:int m_clock; //时钟序列};（3）主要成员函数的实现：void CProMoni::InsertRQ(PCB* p){ //将p插入到就绪队列中POSITION pre,pos=m_readyList.GetHeadPosition();PCB *q;while(pos!=NULL){pre=pos;q=(PCB*)m_readyList.GetNext(pos);if(q->pri < p->pri){m_readyList.InsertBefore(pre,p);return;}}if(pos==NULL){m_readyList.AddTail(p);}}void CProMoni::ProSchedule(){//进程调度PCB *p;if(m_pRunning==NULL){if(m_readyList.IsEmpty()){m_finish=true;return;}else{p=(PCB*)m_readyList.RemoveHead();m_pRunning=p;}}else{if(!m_readyList.IsEmpty()){p=(PCB*)m_readyList.GetHead();//m_readyList将头节点与当前PCB的权值比较if(p->pri > m_pRunning->pri ){PCB *q=m_pRunning;m_pRunning=(PCB*)m_readyList.RemoveHead();m_pRunning->status=1;q->status=0;InsertRQ(q);}}}}void CProMoni::ProRun(){//运行进程if(!m_finish){if(m_pRunning==NULL){ AfxMessageBox("当前运行的进程不存在!");return;}m_pRunning->pri-=3;m_pRunning->time-=1;{ m_pRunning->time=0;PCB*p=m_pRunning;p->status=-1;InsertFQ(p);m_pRunning=NULL;}}}（4）试图类的主要成员函数：PCB* CProcessView::CreatePCB(){//创建PCBPCB* p=new PCB;p->pid=n+1;p->pri=m_pris[n];p->time=m_times[n];p->status=0;n++;return p;}#include"pritimedlg.h"void CProcessView::OnStart(){ CPriTimeDlg dlg; //定义数据录入对话框dlg.DoModal();if(dlg.m_ok){ m_proTotal=dlg.m_proNum;for(int i=0;i<m_proTotal;i++){ m_pris[i]=dlg.m_pris[i];m_times[i]=dlg.m_times[i];}m_proMoni.OpenLogFile(); //打开日志文件PCB* p=CreatePCB(); //创建新进程m_proMoni.InsertRQ(p); //将新进程插入到就绪队列中m_proMoni.WriteLogToFile(); //写日志文件m_proMoni.ProSchedule(); //进程调度m_start=true; //设置开始标志Invalidate(); //刷新视图m_killTimer=false;SetTimer(1,1000,NULL);//设置定时器}}void CProcessView::OnTimer(UINT nIDEvent){ m_proMoni.m_clock++;m_proMoni.WriteLogToFile();//写日志m_proMoni.ProRun(); //运行进程if(n<m_proTotal){ PCB *p=CreatePCB();//创建新进程m_proMoni.InsertRQ(p);}m_proMoni.ProSchedule();Invalidate();if(m_proMoni.GetFinishFlag()){//若已完成则删除定时器KillTimer(1);m_killTimer=true;AfxMessageBox("演示完毕");}CScrollView::OnTimer(nIDEvent);}五．运行结果（1）数据录入界面：（2）进程调度过程的结果：六、实验总结通过本实验使我对进程的相关概念及进程的优先数调度算法有了更深的理解，使自己在程序设计及编制方面也有了一定的提高。
实验报告二 进程调度算法
实验报告二——进程调度算法的设计姓名: xxxx 学号: xxxxx班级: xxxx一、实习内容•实现短进程优先调度算法（SPF）•实现时间片轮转调度算法（RR）二、实习目的•通过对进程调度算法的设计, 深入理解进程调度的原理。
进程是程序在一个数据集合上运行的过程, 它是系统进行资源分配和调度的一个独立单位。
进程调度分配处理机, 是控制协调进程对CPU的竞争, 即按一定的调度算法从就绪队列中选中一个进程, 把CPU的使用权交给被选中的进程。
三、实习题目• 1.先来先服务（FCFS）调度算法原理: 每次调度是从就绪队列中, 选择一个最先进入就绪队列的进程, 把处理器分配给该进程, 使之得到执行。
该进程一旦占有了处理器, 它就一直运行下去, 直到该进程完成或因发生事件而阻塞, 才退出处理器。
将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列, 并按照先来先服务的方式进行调度处理, 是一种最普遍和最简单的方法。
它优先考虑在系统中等待时间最长的作业, 而不管要求运行时间的长短。
按照就绪进程进入就绪队列的先后次序进行调度, 简单易实现, 利于长进程, CPU繁忙型作业, 不利于短进程, 排队时间相对过长。
• 2.时间片轮转调度算法RR原理: 时间片轮转法主要用于进程调度。
采用此算法的系统, 其程序就绪队列往往按进程到达的时间来排序。
进程调度按一定时间片(q)轮番运行各个进程.进程按到达时间在就绪队列中排队, 调度程序每次把CPU分配给就绪队列首进程使用一个时间片, 运行完一个时间片释放CPU, 排到就绪队列末尾参加下一轮调度, CPU分配给就绪队列的首进程。
固定时间片轮转法:1 所有就绪进程按FCFS 规则排队。
2 处理机总是分配给就绪队列的队首进程。
3 如果运行的进程用完时间片, 则系统就把该进程送回就绪队列的队尾, 重新排队。
4 因等待某事件而阻塞的进程送到阻塞队列。
5 系统把被唤醒的进程送到就绪队列的队尾。
操作系统实验之处理机调度实验报告
1、开发工具
Clion for mac 2016，采用 cmake 编译。
2、主要源码
//先来先服务 void FCFS(List *p, int count) {
List temp; int i, j; //按照到达时间排序 for (i = 1; i < count; i++) {
min = 100; temp = p[k].Finish_time; for (j = 0; j < count; j++) {
if (p[j].order != 0 || temp - p[j].Arrival_time < 0) continue;
if (min > p[j].Service_time) {
max = 0;
temp = p[k].Finish_time; //找响应比最高任务 for (j = 0; j < count; j++) {
if (p[j].order != 0 || temp - p[j].Arrival_time <= 0) continue;
if (max < (temp - p[j].Arrival_time) / p[j].Service_time) {
if (temp > p[i].Arrival_time) {
temp = p[i].Arrival_time; k = i; } } //按照响应比大小设置优先级，以及相应参数 for (i = 0; i < count; i++) { p[k].order = ++flag; p[k].Start_time = temp; p[k].Wait_time = temp - p[k].Arrival_time; p[k].Finish_time = temp + p[k].Service_time; p[k].Turnover_time = p[k].Finish_time - p[k].Arrival_time; p[k].WeightedTurn_time = p[k].Turnover_time / p[k].Service_time;
处理机调度
实验二（进程）处理器调度一、实验内容选择一个调度算法，实现处理器调度。
二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。
本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。
三、实验题目本实习有两个题，学生可选择其中的一题做实习。
第一题：设计一个按优先数调度算法实现处理器调度的程序。
[提示]：(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。
指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。
状态——可假设有两种状态，“就绪”状态和“结束”状态。
五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。
(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。
(3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。
用一单元指出队首进程，用指针指出队列的连接情况。
例：队首标志K2K3K4K5(4) 处理器调度总是选队首进程运行。
采用动态改变优先数的办法，进程每运行一次优先数就减“1”。
由于本实习是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数-1要求运行时间-1来模拟进程的一次运行。
提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。
在这里省去了这些工作。
(5) 进程运行一次后，若要求运行时间 0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。
实现处理机调度课程设计
实现处理机调度课程设计一、课程目标知识目标：1. 让学生理解处理机调度的基本概念，掌握其功能和重要性；2. 学会分析不同处理机调度算法的特点和优缺点；3. 掌握几种常见的处理机调度算法，如先来先服务、短作业优先、优先级调度等；4. 了解处理机调度在操作系统中的作用和影响。
技能目标：1. 培养学生运用处理机调度算法解决实际问题的能力；2. 提高学生分析、设计、优化调度算法的技能；3. 学会使用相关工具和软件模拟处理机调度过程。
情感态度价值观目标：1. 培养学生对操作系统学科的兴趣和热情；2. 增强学生的团队合作意识和解决问题的能力；3. 引导学生认识到处理机调度在提高计算机系统性能方面的重要性。
分析课程性质、学生特点和教学要求：1. 课程性质：本课程为计算机科学与技术专业核心课程，具有较强的理论性和实践性；2. 学生特点：学生已具备一定的计算机操作系统知识，具备一定的编程基础；3. 教学要求：结合实际案例，采用任务驱动法，引导学生主动探索和解决问题。
二、教学内容1. 处理机调度基本概念：处理机调度的定义、作用、分类和性能指标；2. 处理机调度算法：- 先来先服务（FCFS）调度算法；- 短作业优先（SJF）调度算法；- 优先级调度算法；- 时间片轮转调度算法；- 多级反馈队列调度算法；3. 处理机调度算法性能分析：分析各种调度算法的优缺点及适用场景；4. 处理机调度算法实现：结合实际案例，编写程序实现各种调度算法；5. 处理机调度在操作系统中的应用：探讨处理机调度在操作系统中的重要性及影响。
教学安排和进度：第1周：处理机调度基本概念；第2周：先来先服务（FCFS）调度算法；第3周：短作业优先（SJF）调度算法；第4周：优先级调度算法；第5周：时间片轮转调度算法；第6周：多级反馈队列调度算法；第7周：处理机调度算法性能分析；第8周：处理机调度算法实现及实践；第9周：处理机调度在操作系统中的应用。
教材章节关联：《计算机操作系统》第3章“处理机管理”，第4章“进程调度与死锁”，结合课本内容进行讲解和拓展。
操作系统实验报告-单处理机系统的进程调度
实验二单处理机系统的进程调度一．实验目的（1）加深对进程概念的理解，明确进程与程序的区别。
（2）深入了解系统如何组织进程、创建进程。
（3）进一步认识如何实现处理机调度。
二．实验内容编写程序完成单处理机系统中的进程调度，要求采用时间片轮转调度算法。
三．实验原理在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片.时间片的大小从几ms到几百ms.当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间.四．实验部分源程序#include<stdio.h>#include<time.h>#include<stdlib.h>/*********************以下是全局数据结构和变量***********************//*PCB 结构*/struct PCB{int pname;int pri;int runtime;int waittime;struct PCB *next;}pcb[7];struct PCB *running; /* 运行指针*/struct PCB *Hready; /*高优先级就绪队列头指针*/struct PCB *Lready; /*低优先级队列头指针*/struct PCB*wait; /*等待队列头指针*/int A=0;/**************************以下是函数说明****************************/ void delay(); /*利用循环实现延迟*/void proc(struct PCB *running); /*模拟进程3－9*/void InsertIntoQueueTail(struct PCB **head,struct PCB *node); /*将node插入到head所指示的队列的尾部*/int proc_switch(); /*进程调度函数*/void proc_wait(); /*进程等待函数*/int proc_wakeup(); /*进程唤醒函数*//************************以下是函数定义及注释************************/ main() /*主函数*/{ int i;/*初始化，创建进程3－9，置低优先级，等待时间为0,依次插入低优先级队列*/for(i=0;i<3;i++){pcb[i].pname=i+3;pcb[i].pri=0;pcb[i].waittime=0;InsertIntoQueueTail(&Lready,&pcb[i]);}wait=NULL;Hready=NULL; /*等待队列和高优先级队列为空*/printf("\n模拟进程调度开始:\n"); /*模拟进程调度开始*/for(;;){ switch(A){case 0:/*无进程等待调度，打印信息并返回*/if(!proc_switch()){printf("/n没有进程在运行返回:\n");getchar(); }break;case 1:proc_wait();break;case 3:case 4:case 5:case 6:proc(running); break;default:printf("\nerror!");exit(-1); }}}/*功能：延迟一个时间片*//*入口参数：无*//*出口参数：无*/void delay(){ int i,j;for(i=0;i<20000;i++)for(j=0;j<10000;j++){}}/*功能：进程3－9*//*入口参数：运行指针*//*出口参数：无*/void proc(struct PCB * running){ int i;srand( (unsigned)time( NULL ) );/*显示当前运行的进程的id*/printf("\n现在进程%d 正在运行\n",running->pname);/*当前进程执行running->runtime个时间片*/for(i=running->runtime;i>0;i--){/*显示剩余的时间片*/printf("剩余的时间片为%d\n",i);/*延迟*/delay();proc_wakeup();/*产生一个1到1000的随机数，若该随机数小余300，当前进程等待，*/ if((rand()%1000+1)<300){printf("进程%d开始等待.\n",running->pname);A=1;return; }}/*显示时间片耗尽，进程转为低优先级就绪状态*/printf("进程%d时间片耗尽\n",running->pname);InsertIntoQueueTail(&Lready,running);A=0;return; }/*功能：将一个节点插入队列尾部*//*入口参数：队列头指针地址head，待插入结点node*//*出口参数：无*/void InsertIntoQueueTail(struct PCB **head,struct PCB *node){ struct PCB *p;node->next=NULL;/*被插入队列为空*/if(*head==NULL){*head=node;return; }/*被插入队列不为空*/else{p=*head;/*找到队列的最后一个结点*/while(p->next!=NULL)p=p->next; p->next=node; }}/*功能：进程调度*//*入口参数：无*//*出口参数：若调度成功，返回1，否则返回0*/int proc_switch() {/*若高优先级就绪队列和低优先级就绪队列均为空，则循环执行进程唤醒*/while(Hready == NULL && Lready == NULL)if(!proc_wakeup()) return 0;/*若高优先级就绪队列非空，则执行其第一个进程，分配2个时间片*/if(Hready!=NULL){running=Hready;Hready=Hready->next;running->runtime=2; }/*若高优先级就绪队列为空，则执行低优先级就绪队列的第一个进程，分配5个时间片*/else{running=Lready;Lready=Lready->next;running->runtime=5; }/*把调度进程的id赋给A*/A=running->pname;return 1; }/*功能：进程等待。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统实验2：处理机调度
实验目的
模拟在单处理器多进程操作系统的CPU调度。
帮助学生掌握多种CPU调度算法的知识原理和运作机制。
本实验为模拟实验，不要求实现真正的进程创建与进程调度。
主要实现各种调度算法。
实验内容
进程PCB结构：标识符、进程名称、到达时间、服务时间、剩余运行时间、已使用时间、进程状态。
其中进程状态有三种：就绪R，运行E，结束F。
剩余运行时间和已使用时间两个属性用于时间片轮转算法和多级反馈队列算法。
进程每使用完一个时间片，已使用时间就会增加一个时间片的长度，剩余运行时间=服务时间–已使用时间。
例程提供了两种测试数据：一种是程序内置数据，通过语句已经预先设置好，存放在数组pcbdata中，数据来源于课本P76第二个表格的数据，共5个进程。
另一种方法是手工输入，使用函数input()，输入数据同样存放在数组pcbdata中。
如果使用input函数，内置数据将不会使用。
例程已经实现先来先服务算法，请仔细阅读，掌握算法的原理和调度过程。
为了检验算法的正确性，大家对测试数据用笔算推导，然后与程序运行结果对比，检查算法是否正确。
实验要求
1、阅读理解例程，掌握例程的运作流程。
运行例程，理解先来先服务算法的调
度原理和运行结果。
2、参考先来先服务算法，尝试实现其他四种调度算法：短作业优先、高响应比、
时间片轮转、多级反馈队列。
要求至少实现一种算法。
a)除了多级反馈队列，其他算法采用非抢占调度
b)短作业优先算法使用例题一数据或程序内置数据，要求运行结果给出调
度顺序、完成时间、周转时间、带权周转时间
c)高响应比算法使用例题二的数据，要求运行结果给出调度顺序、完成时
间、周转时间、带权周转时间
d)时间片轮转算法可以使用程序内置数据，要求运行结果给出每个时间片
是被哪个进程使用，每个进程完成时，要修改状态并输出提示。
e)多级反馈队列算法使用例题三的数据，要求运行结果给出正确的进程调
度顺序和过程描述。
例题一：在单处理机环境下，对4个作业Job1、Job2、Job3、Job4进行非抢占式调度，它们的到达时间均为1，所需运行时间分别为9、16、3、11。
例题二：在单处理机环境下，对4个进程P1、P2、P3、P 4进行非抢占式调度，它们的到达时间分别为10、12、14、16，运行时间分别为8、12、4、6。
例题三：在某一操作系统中对进程调度采用多级反馈队列调度算法。
现设定采用三级反馈队列调度算法，三个队列分别为I、II、III，对应时间片为2、4、8。
现有四个进程A、B、C、D，到达时刻分别为0、5、7、12，执行时间分别为7、4、13、9。
请写出整个进程调度过程。
例程。