进程调度算法模拟程序设计C++
用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进程运行一次后，把该进程控制块的指针值送到标志单元，以指示下一个轮到的进程。
动态优先权进程调度算法模拟实验报告
动态优先权进程调度算法模拟实验报告动态优先权调度算法是一种动态调度算法，根据进程的优先级来决定下一个要执行的进程。
进程的优先级可以根据其紧迫性、重要性和资源需求等因素来确定。
本实验利用模拟算法来模拟动态优先权调度算法，并通过实例来说明该调度算法的工作原理和优缺点。
一、实验目的通过本实验，我们可以了解动态优先权调度算法的工作原理，掌握如何使用模拟算法来模拟进程的调度过程，进一步了解该调度算法的优缺点。
二、实验环境本实验使用C++编程语言来实现动态优先权调度算法的模拟。
编译器使用Dev-C++。
三、实验步骤1.设计进程控制块（PCB）的数据结构，包括进程优先级、进程标识、进程状态等信息。
2.设计模拟算法来模拟动态优先权调度算法。
具体算法如下：a.初始化就绪队列，将所有的进程按照优先级插入到就绪队列中。
b.选择优先级最高的进程执行，并更新该进程的优先级。
c.执行完毕后更新进程的状态，并将其从就绪队列中删除。
d.如果新的进程到达，将其插入到就绪队列中。
3.实现主函数，模拟进程的创建、调度和执行过程。
4.进行多个实例的测试，观察进程的调度顺序和执行结果。
5.总结实验结果，分析动态优先权调度算法的优缺点。
四、实验结果与分析通过多个实例的测试，我们可以观察到动态优先权调度算法的工作过程和效果。
该算法可以根据进程的优先级来确定下一个要执行的进程，从而可以更好地满足不同进程的需求。
同时，动态优先权调度算法可以确保优先级高的进程能够及时得到执行，提高系统的响应速度。
然而，动态优先权调度算法存在一些缺点。
首先，该算法对进程的优先级要求较高，需要合理设置进程的优先级。
如果优先级设置不合理，可能导致优先级高的进程一直占用CPU资源，而优先级低的进程无法得到执行，造成资源浪费。
其次，该算法没有考虑进程的等待时间和执行时间，容易导致饥饿现象的发生，即一些进程无法得到执行。
五、实验总结通过本实验，我们了解了动态优先权调度算法的工作原理和模拟方法。
进程的调度实验报告(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("无效的调度算法选择。
OS实验一
否
进程时间 片数为0? 是 撤消该进程
撤消该进程
否
进程队列空?
是
否 结束 是 进程队列空?
2、时间片轮转算法说明 （1）PCB的结构（如下图所示）：轮转法中，设PCB的结构如 右图所示，其中各数据项的含义如下： Id：进程标识符号，取值1—5。 Span：在某一轮中，分配给此进程的时间片数，取值1—3。 Used：现运行进程在本轮执行过程已用的时间片数。 Need：进程尚需的CPU时间数，初值表示该进程需要运行的 总时间，取值范围5—10。并随机产生，每运行一个时间片 need减1；need为0则进程结束。 Status：进程状态R（运行），W（就绪），F（完成）；初始时 所有进程处于就绪状态。 Next：指向就绪队列中下一个进程的PCB的指针。
OS实验一
进程调度
1、实验目的：本次实验要求用C语言编写一个进程调度 模拟程序，使用优先级或时间片轮转法实现进程调 度。目的是理解进程调度算法及其应用。 2、实验环境：Turbo C 2.0/3.0或VC++6.0 3、实验学时： 4学时，必做实验。 4、实验内容 1）设计有5个进程并发执行的模拟调度程序，每 个程序由一个PCB表示。 2）模拟调度程序可任选两种调度算法之一实现。 3）程序执行中应能在屏幕上显示出各进程的状态 变化，以便于观察调度的整个过程。
RUN
1
HEAD
Tail
3
5
… …
2
0 …
…
RUN ----当前运行进程指针； HEAD──就绪进程队列的ＰＣＢ链链首指针； TAIL──就绪进程队列的ＰＣＢ链链尾指针；
… R
W
W
W
输入调度算法Alg
pritity
进程调度模拟程序 操作系统课程设计
算法－－－进程调度模拟程序问题：进程调度模拟程序设计要求：编写一个进程调度程序，允许多个进程共行的进程调度程序。
进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
每个进程有一个进程控制块（PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为输入进程的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止调度算法的流程图如下:算法实现过程：设计实现流程图设计思想说明：用定义结构体来表示进程控制块函数说明：AddProcess(): 来增加进程sort()：按优先级和到达时间排序print()：打印attemper()：调度代码：#include "stdio.h"#include<windows.h>#define Time int#define Max 100typedef struct process{char name[10];//进程名int priority;Time ReachTime;//到达时间Time NeedTime;//需要时间Time UsedTime;//已用时间char state;//状态}PCB;//进程控制块int n;//标示进程的总数PCB pcb[Max];int pTime;//时间片大小void AddProcess(){char ch;do {system("cls");printf(" n 请输入进程名");scanf("%s",pcb[n].name);printf(" 请输入进程的优先级(0-10)");scanf("%d",&pcb[n].priority);printf(" 请输入进程需要的时间");scanf("%d",&pcb[n].NeedTime);pcb[n].ReachTime=n;pcb[n].UsedTime=0;pcb[n].state='W';n++;do{system("cls");printf("还要继续增加进程吗，是(Y),否(N)");ch=getche();} while(ch!='Y'&&ch!='N'&&ch!='y'&&ch!='n');}while (ch=='Y'||ch=='y');}// 排序函数，将最先运行的进程放在最先即pcb[0]{//用冒泡排序int i,j;PCB temp;//先按到达时间排序for (i=0;i<n-1;i++){for (j=n-2;j>=i;j--){if (pcb[j+1].ReachTime<pcb[j].ReachTime){temp=pcb[j];pcb[j]=pcb[j+1];pcb[j+1]=temp;}}}//再按优先级进行排序for (i=0;i<n-1;i++){for (j=n-2;j>=i;j--){if (pcb[j+1].priority>pcb[j].priority){temp=pcb[j];pcb[j]=pcb[j+1];pcb[j+1]=temp;}}}if (pcb[0].state!='F'){pcb[0].state='R';//将优先级最高的状态置为运行}}//打印void print(){int i;//system("cls");sort();printf(" n t进程名t优先级t到达时间t需要时间t已用时间t状态n");for (i=0;i<n;i++)printf("%10s%10d%10d%15d%15d%15cn",pcb[i].name,pcb[i].priority,pcb[i].ReachTime,pcb[i].NeedTime,pcb[i].UsedTime,pcb[i].state);}}//调度void attemper(){system("cls");printf("调度前：n");print();if ((pcb[0].NeedTime-pcb[0].UsedTime)>pTime){pcb[0].UsedTime+=pTime;//已用时间等于时间片pcb[0].priority--;//优先级减一pcb[0].state='W';}else{pcb[0].UsedTime=pcb[0].NeedTime;//已用时间等于需要时间pcb[0].priority=-1000;//优先级置为零pcb[0].state='F';//完成进程，将状态置为完成}printf("调度后: n");print();}char face(){char choose;printf(" n------------------------------------------- n");printf(" t增加进程，请按1 n");printf(" t打印进程，请按2 n");printf(" t进程调度，请按3 n");printf(" t结束进程请,按0 n");printf(" n------------------------------------------- n");printf(" t请选择:");do{choose=getche();} while(choose!='1'&&choose!='2'&&choose!='3'&&choose!='0');return choose;}void main(){char choose;n=0;//初始化进程数为0 printf("设置时间片的大小");scanf("%d",&pTime);system("cls");choose=face();do{if (choose=='1'){AddProcess();print();}if (choose=='2'){system("cls");print();}if (choose=='3'){attemper();}if (choose=='0'){return;}choose=face();} while(1);}。
操作系统进程调度算法模拟实验
操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能，它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。
为了更好地理解进程调度算法的工作原理，我们可以进行一个模拟实验来观察不同算法的表现效果。
实验设想：我们设想有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。
进程调度算法模拟程序设计
进程调度算法模拟程序设计引言进程调度算法是操作系统中的重要组成部分，它决定了进程在系统中的执行顺序和分配时间片的策略。
为了更好地理解和研究不同的进程调度算法，我们可以设计一个模拟程序来模拟进程的调度过程。
本文将介绍进程调度算法的基本概念和常见的调度算法，并详细讨论如何设计一个进程调度算法模拟程序。
什么是进程调度算法进程调度算法是操作系统中的一种策略，用于决定在多个进程同时请求执行时，系统按照什么样的顺序来选择并分配CPU资源。
进程调度算法的目标是尽可能地提高系统的吞吐量、响应时间和公平性。
常见的进程调度算法先来先服务（FCFS）先来先服务是最简单的进程调度算法，它按照进程到达的先后顺序进行调度。
当一个进程到达系统后，它会被放入就绪队列中，然后按照先后顺序执行。
这种算法的优点是简单易懂，但是存在”饥饿”问题，即长作业会占用CPU资源，导致其他短作业等待时间过长。
短作业优先（SJF）短作业优先算法是根据进程的执行时间来进行调度的。
当一个进程到达系统后，系统会根据其执行时间将其放入适当的位置，执行时间短的进程优先执行。
这种算法可以最大限度地减少平均等待时间，但是对于长作业来说可能会饥饿。
时间片轮转（RR）时间片轮转算法是一种分时调度算法，它将CPU的执行时间划分为多个时间片，每个进程在一个时间片内执行一定的时间，然后切换到下一个进程。
这种算法可以保证所有进程都有机会执行，并且对于响应时间要求较高的任务比较合适。
多级反馈队列（MFQ）多级反馈队列算法是一种综合了FCFS和RR的调度算法。
系统将进程根据优先级划分为多个队列，每个队列都有不同的时间片大小。
当一个进程到达系统后，它被放入第一个队列中，如果在时间片内没有执行完，则被移到下一个队列中。
这种算法可以根据进程的优先级和执行时间动态调整调度策略，提高系统的响应性能。
进程调度算法模拟程序设计程序结构为了设计一个进程调度算法模拟程序，我们需要考虑以下几个方面的内容：1.进程的数据结构：我们可以使用一个进程控制块（PCB）来表示一个进程，PCB包含了进程的状态、优先级、执行时间等信息。
操作系统综合性实验报告-进程调度(含代码)
int count;
// 记录进程执行的次数
struct node *next;
// 队列指针
}PCB;
PCB *ready=NULL,*run=NULL,*finish=NULL; // 和完成队列
定义三个队列， 就绪队列， 执 行队列
int num; void GetFirst(); void Output(); void InsertTime(PCB *in); void InsertFinish(PCB *in); TimeCreate(); void RoundRun(); void main() {
三、实验内容
1. 用 C 语言（或其它语言，如 Java ）编程实现对 N 个进程采用某种进程调度算
法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度
算法）调度执行的模拟。
2. 每个用来标识进程的进程控制块 typedef struct node {
PCB 可用结构来描述，包括以下字段：
一个时间片，当执行完时，有一个计时器发出时钟中断请求，该进程停止，并被送
到就绪队列的末尾，然后再把处理机分配就绪队列的队列进程，同时也让它执行一
个时间片。 （ 3 ）、通过亲手实验， 对上述写的时间片的工作流程和原理有了更贴切的认识。
另外本次实验遇到了很大的麻烦，其实大部分代码是借鉴网上的，但自己通过修改， 来获取自己想要的，在自己的努力和同学的帮助下终于调试正确，很是高兴。
void InsertTime(PCB *in)
// 将进程插入到就绪队列尾部
{ PCB *fst; fst = ready;
if(ready == NULL) {
in->next = ready; ready = in; } else { while(fst->next != NULL) {
进程调度实验报告答案(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.写出你对给出的程序的理解，可以包括学到了那些程序设计的语法或方法，以及算法的设计思想。
2.写出实验指导中要求部分是如何实现的，
3.上述部分不能只是抄写代码，要有说明。
附录： 先来先服务进程调度模拟程序
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
printf("----------------------------------------------------------------------------------------------\n");
for(int i=0;i<N;i++)
{
printf(" %s %d %d %d %d \n",pcb[i].name,pcb[i].arrive_time,pcb[i].run_time,pcb[i].finish_time,pcb[i].zhouzhuan_time);
#include <conio.h>
#define N 5
struct PCB
{
char name[8];
int arrive_time;
int run_time;
int finish_time;
int zhouzhuan_time;
};
int total=0;
struct PCB pcb[N],temp;
output();
//运行第一个到达的进程得到它的完成时间、周转时间等,并设置为已访问
pcb[0].finish_time=pcb[0].arrive_time+pcb[0].run_time;
进程调度算法模拟实验报告
竭诚为您提供优质文档/双击可除进程调度算法模拟实验报告篇一：操作系统进程调度算法模拟实验报告进程调度算法模拟专业：xxxxx学号：xxxxx姓名：xxx实验日期：20xx年xx月xx日一、实验目的通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。
二、实验要求编写程序实现对5个进程的调度模拟，要求至少采用两种不同的调度算法分别进行模拟调度。
三、实验方法内容1.算法设计思路将每个进程抽象成一个控制块pcb，pcb用一个结构体构建一个进程调度类。
将进程调度的各种算法分装在一个类中。
类中存在三个容器，一个保存正在或未进入就绪队列的进程，一个保存就绪的进程，另一个保存已完成的进程。
还有一个pcb实例。
主要保存正在运行的进程。
类中其他方法都是围绕这三个容器可以这个运行中的pcb展开。
主要用到的技术是sTL中的vector以维护和保存进程容器、就绪容器、完成容器。
当程序启动时，用户可以选择不同的调度算法。
然后用户从控制台输入各个进程的信息，这些信息保存到进程容器中。
进程信息输入完毕后，就开始了进程调度，每调度一次判断就绪队列是否为空，若为空则系统时间加一个时间片。
判断进程容器中是否有新的进程可以加入就绪队列。
2.算法流程图主程序的框架：();//先来先服务();//最短进程优先调度//简单时间片轮转//最高优先数优先//输入进程信息();.m_waitQueue.empty()||.m_processQueue.empt() ();进程调度过程：;3.算法中用到的数据结构structfcfs{//先来先服务算法从这里开始charname[10];floatarrivetime;floatservicetime;float starttime;floatfinishtime;floatzztime;floatdqzztime;};//定义一个结构体，里面包含的有一个进程相关的信息4.主要的常量变量vector m_processQueue;//进程输入队列vector m_waitQueue;//进程就绪队列vectorm_FinishQueue;//完成队列vect(:进程调度算法模拟实验报告)or ::iteratorm_iter;//迭代器pcbm_runprocess;//运行中的进程intm_processcount;//进程数floatm_RunTime;//运行时间intm_tagIsRun;//是否在运行标志。
c语言实现多级反馈队列调度的算法模拟进程的控制
c语言实现多级反馈队列调度的算法模拟进程的控制目录1. 引言1.1 背景和意义1.2 结构概述1.3 目的2. 多级反馈队列调度算法2.1 基本原理2.2 算法设计思路2.3 算法流程图3. C语言实现模拟进程控制3.1 数据结构定义3.2 进程创建与销毁3.3 进程调度与执行4. 实验结果与分析4.1 实验环境介绍4.2 实验结果展示4.3 结果分析与讨论5. 结论与展望5.1 结论总结5.2 存在问题与改进方向1. 引言1.1 背景和意义在计算机科学领域，进程调度是操作系统中非常重要的一个功能。
它负责决定哪个进程可以使用CPU并以何种顺序执行。
进程调度算法的优劣直接影响了系统的性能和效率。
多级反馈队列调度算法是一种常用的进程调度算法之一，它可以根据进程的类型和优先级将进程划分到不同的队列中，并根据优先级来决定进程的执行顺序。
该算法兼具公平性和高响应时间两个特点，适合应用于多任务环境下。
本文旨在使用C语言实现模拟多级反馈队列调度算法，并通过模拟进程控制过程，探讨其在实际应用中的表现。
通过实验结果与分析，我们将评估该算法在不同场景下的性能指标，并对其中存在问题提出改进方向。
1.2 结构概述本文共分为五个部分组成：•引言：介绍本文撰写目的、研究背景以及多级反馈队列调度算法在进程控制中的重要性。
•多级反馈队列调度算法：详细介绍多级反馈队列调度算法的基本原理、设计思路和算法流程图。
•C语言实现模拟进程控制：描述C语言中如何定义数据结构以及实现进程的创建、销毁以及调度和执行过程。
•实验结果与分析：介绍实验环境并展示实验结果，对结果进行分析和讨论。
•结论与展望：总结本文的研究成果，并提出该算法在应用过程中存在的问题以及改进方向。
通过以上结构安排，我们将全面深入地探讨多级反馈队列调度算法在模拟进程控制中的应用。
1.3 目的本文旨在通过使用C语言实现多级反馈队列调度算法，模拟进程控制过程。
通过对该算法进行分析和实验，目标如下：1.探讨多级反馈队列调度算法在不同场景下的优劣势，并对其性能指标进行评估。
进程调度实验报告源码
一、实验目的本次实验旨在通过模拟进程调度过程，加深对进程调度算法的理解，并掌握进程调度程序的设计与实现方法。
实验内容主要包括：创建进程、进程调度、进程执行、进程结束等。
二、实验环境操作系统：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算法能够保证最短执行时间的进程先执行，因此平均等待时间较短。
但如果有一个执行时间很长的进程到达，其他进程的等待时间就会变长。
实验报告操作系统实验一进程调度.doc
计算机电子信息工程学院实验报告成绩________ 课程名称操作系统指导教师杨秀华实验日期 2011年9月15、22、29,10月12院（系）计算机学院专业班级09计算机应用实验地点 B-4009学生姓名学号实验项目名称实验一模拟设计进程调度一、实验目的和要求用C或C++语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解．二、实验原理进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
每个进程有一个进程控制块（ PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪 W（Wait）、运行R（Run）状态之一。
就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1（即降低一级）,然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB,以便进行检查。
重复以上过程,直到所要进程都完成为止。
三、主要仪器设备或材料PC机,C++环境四、实验方法与步骤（可加附页）1、主要数据结构：struct pcb { /* 定义进程控制块PCB */char name[10]; //进程名字char state; //进程状态int super; //进程的优先级int ntime; //进程需要运行的时间int rtime; //进程已经运行的时间struct pcb* link; }2、调度算法的流程图如上图 :五、实验数据记录、处理及结果分析六、讨论、心得计算机电子信息工程学院实验报告（附页）程序参考代码：参考代码：#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0struct pcb{ /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;void 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;}}void input() /* 建立进程控制块函数*/{int i,num;printf("\n 请输入进程号?");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 进程号No.%d:\n",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);}Void 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");}Void check() /* 建立进程查看函数 */{PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}Void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{3 / 4printf("\n 进程 [%s] 已完成.\n",p->name);free(p);}Void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ {(p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='w';sort(); /*调用sort函数*/}}Void 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();}知识改变命运。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
（1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。
（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：✧进程标识数ID。
✧进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
✧进程已占用CPU时间CPUTIME。
✧进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0。
✧进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。
✧进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
✧进程状态STATE。
✧队列指针NEXT，用来将PCB排成队列。
（3）优先数改变的原则：✧进程在就绪队列中呆一个时间片，优先数增加1。
✧进程每运行一个时间片，优先数减3。
（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
（5）分析程序运行的结果，谈一下自己的认识。
实验代码#include "iostream.h"#include "windows.h"//#define N 3typedef struct{int ID;int PRIORITY;int CPUTIME;int ALLTIME;int STARTBLOCK;int BLOCKTIME;int STATE;//0-运行1-阻塞2-就绪3-结束4-未到达int REACH;int TIME;}PROCESS;void textcolor (int color){SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color ); }void main(){int i,time,max,l,l1,time1,flag=0,total=0,N,server[10],sum=0;PROCESS pro[10];textcolor(13);cout<<"注意：本程序中状态代表如下"<<endl<<"0-运行1-阻塞2-就绪3-结束4-未到达"<<endl<<endl;textcolor(15);cout<<"请输入进程数:";cin>>N;cout<<"请设置时间片长度:";cin>>time;cout<<"请输入各进程初始状态:"<<endl;cout<<"ID PRIORITY REACH ALLTIME STARTBLOCK BLOCKTIME"<<endl;for(i=0;i<N;i++){pro[i].CPUTIME=0;pro[i].TIME=0; //结束时间cin>>pro[i].ID>>pro[i].PRIORITY>>pro[i].REACH;cin>>pro[i].ALLTIME>>pro[i].STARTBLOCK>>pro[i].BLOCKTIME;server[i]=pro[i].ALLTIME;if(pro[i].REACH==0) pro[i].STATE=0;else pro[i].STATE=4;}do{cout<<endl<<"当前时刻为:"<<total; //total当前的时刻textcolor(12);cout<<endl<<"========================各进程状态为======================"<<endl;textcolor(15);cout<<"ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE"<<endl;for(i=0;i<N;i++){cout<<pro[i].ID<<" "<<pro[i].PRIORITY<<" "<<pro[i].CPUTIME<<" ";cout<<pro[i].ALLTIME<<" "<<pro[i].STARTBLOCK<<" "<<pro[i].BLOCKTIME<<" "<<pro[i].STATE;cout<<endl;}total+=time; //time为时间片长for(i=0;i<N;i++){if(pro[i].STATE==4&&pro[i].REACH<total){ //？？？？？pro[i].STATE=1; //进程阻塞}}for(i=0;i<N;i++){time1=pro[i].ALLTIME; //进程需要时间if(pro[i].STATE==0){if(pro[i].ALLTIME<=time){//pro[i].CPUTIME+=time1;pro[i].ALLTIME=0;pro[i].STATE=3;pro[i].TIME=total-time+time1;}else{//pro[i].CPUTIME+=time;pro[i].ALLTIME-=time;pro[i].STARTBLOCK--;if(pro[i].STARTBLOCK==0){pro[i].STATE=1;pro[i].BLOCKTIME=time1;pro[i].STARTBLOCK=time1;}pro[i].PRIORITY-=3;pro[i].TIME=total;}}if(pro[i].STATE==1){pro[i].BLOCKTIME--;if(pro[i].BLOCKTIME==0) pro[i].STATE=2;pro[i].TIME=total;}if(pro[i].STATE==2){//pro[i].CPUTIME+=time;pro[i].PRIORITY++;pro[i].TIME=total;}}max=-100;l1=-1;l=-1;for(i=0;i<N;i++){if(pro[i].PRIORITY>max&&(pro[i].STATE==0||pro[i].STATE==2)){ l=i;max=pro[i].PRIORITY;}if(pro[i].STATE==0) l1=i;}if(l!=-1&&l!=l1) pro[l].STATE=0;if(l1!=-1) pro[l1].STATE=2;flag=0;for(i=0;i<N;i++){if(pro[i].STATE!=3){flag=1;break;}}if(flag==0) break;}while(1);cout<<endl<<"当前时刻:"<<total;textcolor(12);cout<<endl<<"========================各进程状态为======================"<<endl;textcolor(15);cout<<"ID PRIORITY CPUTIME ALLTIME STARTBLOCKBLOCKTIME STATE"<<endl;for(i=0;i<N;i++){cout<<pro[i].ID<<" "<<pro[i].PRIORITY<<" "<<pro[i].CPUTIME<<" ";cout<<pro[i].ALLTIME<<" "<<pro[i].STARTBLOCK<<" "<<pro[i].BLOCKTIME<<" "<<pro[i].STATE;cout<<endl;}cout<<endl<<"各进程运行结束!"<<endl;cout<<"进程号到达时间结束时间周转时间带权周转时间"<<endl;textcolor(10);for(i=0;i<N;i++){cout<<" "<<pro[i].ID<<" "<<pro[i].REACH<<" "<<pro[i].TIME<<" "<<pro[i].TIME-pro[i].REACH<<" "<<(float)(pro[i].TIME-pro[i].REACH)/server[i]<<endl;sum+=pro[i].TIME-pro[i].REACH;}cout<<"平均周转时间为:"<<(float)sum/N<<endl;textcolor(15);}实验结果注意：本程序中状态代表如下0-运行1-阻塞2-就绪3-结束4-未到达请输入进程数:3请设置时间片长度:2请输入各进程初始状态:ID PRIORITY REACH ALLTIME STARTBLOCK BLOCKTIME 优先级到达1 4 5 7 8 32 6 0 7 2 87 3 2 6 2 6当前时刻为:0========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 4 0 7 8 3 42 6 0 7 2 8 07 3 0 6 2 6 4当前时刻为:2========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 4 0 7 8 3 42 3 0 5 1 8 27 3 0 6 2 6 4当前时刻为:4========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 4 0 7 8 3 42 4 0 5 1 8 07 3 0 6 2 5 1当前时刻为:6========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 4 0 7 82 12 1 03 54 17 3 0 6 2 4 1当前时刻为:8========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 4 0 7 8 1 12 1 03 5 3 17 3 0 6 2 3 1当前时刻为:10========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 5 0 7 8 0 02 1 03 5 2 17 3 0 6 2 2 1当前时刻为:12========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 2 0 5 7 0 22 1 03 5 1 17 3 0 6 2 1 1当前时刻为:14========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 3 0 5 7 0 22 2 03 5 0 27 4 0 6 2 0 0当前时刻为:16========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 4 0 5 7 0 02 3 0 3 5 0 27 1 0 4 1 0 2当前时刻为:18========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 1 0 3 6 0 22 4 03 5 0 07 2 0 4 1 0 2当前时刻为:20========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 2 0 3 6 0 22 1 0 1 4 0 27 3 0 4 1 0 0当前时刻为:22========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 3 0 3 6 0 02 2 0 1 4 0 27 0 0 2 4 3 1当前时刻为:24========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 0 0 1 5 0 22 3 0 1 4 0 07 0 0 2 4 2 1当前时刻为:26========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 1 0 1 5 0 02 3 0 0 4 0 37 0 0 2 4 1 1当前时刻为:28========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 1 0 0 5 0 32 3 0 0 4 0 37 1 0 2 4 0 0当前时刻:30========================各进程状态为======================ID PRIORITY CPUTIME ALLTIME STARTBLOCK BLOCKTIME STATE1 1 0 0 5 0 32 3 0 0 4 0 37 1 0 0 4 0 3各进程运行结束!进程号到达时间结束时间周转时间带权周转时间1 5 27 22 3.142862 0 25 25 3.571437 2 30 28 4.66667平均周转时间为:25Press any key to continue#include "iostream.h"#include "windows.h"//#define N 3typedef struct{int ID;int PRIORITY;int CPUTIME;int ALLTIME;int STARTBLOCK;int BLOCKTIME;int STATE;//0-运行1-阻塞2-就绪3-结束4-未到达int REACH;int TIME;}PROCESS;void textcolor (int color){SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color );}void main(){int i,time,max,l,l1,time1,flag=0,total=0,N,server[10],sum=0;PROCESS pro[10];textcolor(13);cout<<"注意：本程序中状态代表如下"<<endl<<"0-运行1-阻塞2-就绪3-结束4-未到达"<<endl<<endl;textcolor(15);cout<<"请输入进程数:";cin>>N;cout<<"请设置时间片长度:";cin>>time;cout<<"请输入各进程初始状态:"<<endl;cout<<"进程名优先级已占用时间还需时间阻塞时间就绪时间状态"<<endl;for(i=0;i<N;i++){pro[i].CPUTIME=0;pro[i].TIME=0;cin>>pro[i].ID>>pro[i].PRIORITY>>pro[i].REACH;cin>>pro[i].ALLTIME>>pro[i].STARTBLOCK>>pro[i].BLOCKTIME;server[i]=pro[i].ALLTIME;if(pro[i].REACH==0) pro[i].STA TE=0;else pro[i].STA TE=4;}do{cout<<endl<<"当前时刻为:"<<total;textcolor(12);cout<<endl<<"========================各进程状态为======================"<<endl;textcolor(15);cout<<"进程名优先级已占用时间还需时间阻塞时间被阻时间状态"<<endl;for(i=0;i<N;i++){cout<<pro[i].ID<<" "<<pro[i].PRIORITY<<" "<<pro[i].CPUTIME<<" ";cout<<pro[i].ALLTIME<<" "<<pro[i].STARTBLOCK<<" "<<pro[i].BLOCKTIME<<" "<<pro[i].STATE;cout<<endl;}total+=time;for(i=0;i<N;i++){if(pro[i].STATE==4&&pro[i].REACH<total){pro[i].STA TE=1;}}for(i=0;i<N;i++){time1=pro[i].ALLTIME;if(pro[i].STATE==0){if(pro[i].ALLTIME<=time){//pro[i].CPUTIME+=time1;pro[i].ALLTIME=0;pro[i].STA TE=3;pro[i].TIME=total-time+time1;}else{//pro[i].CPUTIME+=time;pro[i].ALLTIME-=time;pro[i].STARTBLOCK--;if(pro[i].STARTBLOCK==0){pro[i].STA TE=1;pro[i].BLOCKTIME=time1;pro[i].STARTBLOCK=time1;}pro[i].PRIORITY-=3;pro[i].TIME=total;}}if(pro[i].STATE==1){pro[i].BLOCKTIME--;if(pro[i].BLOCKTIME==0) pro[i].STA TE=2;pro[i].TIME=total;}if(pro[i].STATE==2){//pro[i].CPUTIME+=time;pro[i].PRIORITY++;pro[i].TIME=total;}}max=-100;l1=-1;l=-1;for(i=0;i<N;i++){if(pro[i].PRIORITY>max&&(pro[i].STA TE==0||pro[i].STATE==2)){l=i;max=pro[i].PRIORITY;}if(pro[i].STATE==0) l1=i;}if(l!=-1&&l!=l1) pro[l].STA TE=0;if(l1!=-1) pro[l1].STATE=2;flag=0;for(i=0;i<N;i++){if(pro[i].STATE!=3){flag=1;break;}}if(flag==0) break;}while(1);cout<<endl<<"当前时刻:"<<total;textcolor(12);cout<<endl<<"========================各进程状态为======================"<<endl;textcolor(15);cout<<"进程名优先级已占用时间还需时间阻塞时间被阻时间状态"<<endl;for(i=0;i<N;i++){cout<<pro[i].ID<<" "<<pro[i].PRIORITY<<" "<<pro[i].CPUTIME<<" ";cout<<pro[i].ALLTIME<<" "<<pro[i].STARTBLOCK<<" "<<pro[i].BLOCKTIME<<" "<<pro[i].STATE;cout<<endl;}cout<<endl<<"各进程运行结束!"<<endl;cout<<"进程号到达时间结束时间周转时间带权周转时间"<<endl;textcolor(10);for(i=0;i<N;i++){cout<<" "<<pro[i].ID<<" "<<pro[i].REACH<<" "<<pro[i].TIME<<" "<<pro[i].TIME-pro[i].REACH<<" "<<(float)(pro[i].TIME-pro[i].REACH)/server[i]<<endl;sum+=pro[i].TIME-pro[i].REACH;}cout<<"平均周转时间为:"<<(float)sum/N<<endl;textcolor(15);}。