进程调度算法模拟程序设计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) {
- 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);}。