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

计算机操作系统进程调度实验报告实验报告:计算机操作系统进程调度1.实验背景与目的计算机操作系统是一种负责管理和协调计算机硬件和软件资源的系统。
进程调度作为操作系统的重要功能之一,主要负责决定哪些进程可以运行、何时运行以及运行多长时间等问题。
本实验旨在通过实践学习进程调度的原理和实现细节,加深对操作系统的理解。
2.实验原理与步骤(1)实验原理:进程调度的目标是充分利用计算机资源,提高系统的吞吐率和响应时间。
常用的调度算法有先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)等。
在本实验中,我们将实现时间片轮转调度算法,并对比不同算法的性能差异。
(2)实验步骤:1)设计进程数据结构:创建进程控制块(PCB)结构体,包含进程的标识符、到达时间、服务时间、剩余时间、等待时间等信息。
2)生成进程:根据指定的进程个数和服务时间范围,生成随机的进程并初始化进程控制块。
3)时间片轮转调度算法:根据时间片大小,按照轮转调度的方式进行进程调度。
4)性能评估:通过记录进程的等待时间和周转时间,比较不同调度算法的性能差异。
3.实验结果与分析通过实验我们生成了10个进程,并使用时间片大小为2进行轮转调度。
下表列出了各个进程的信息及调度结果。
进程到达时间服务时间剩余时间等待时间周转时间P108068P214004P3291310P4350115P542032P6570147P763063P8761714P981071P1093104从实验结果可以看出,时间片轮转调度算法相对公平地分配了CPU给各个进程,减少了等待时间和周转时间。
但是,对于长时间服务的进程,可能出现饥饿问题,即一些耗时较长的进程无法得到充分的CPU时间。
与时间片轮转算法相比,先来先服务(FCFS)算法对于短作业具有更好的响应时间,但可能导致长作业等待时间过长。
最短作业优先(SJF)算法能够最大化短作业的优先级,提高整体性能。
4.实验总结与体会本次实验通过实践了解了进程调度的原理与实现细节,加深了对操作系统的理解。
操作系统实验报告进程调度

操作系统实验报告进程调度操作系统实验报告:进程调度引言在计算机科学领域中,操作系统是一个重要的概念,它负责管理和协调计算机系统中的各种资源,包括处理器、内存、输入/输出设备等。
其中,进程调度是操作系统中一个非常重要的组成部分,它负责决定哪个进程在何时获得处理器的使用权,以及如何有效地利用处理器资源。
实验目的本次实验的目的是通过对进程调度算法的实验,深入理解不同的进程调度算法对系统性能的影响,并掌握进程调度算法的实现方法。
实验环境本次实验使用了一台配备了Linux操作系统的计算机作为实验平台。
在该计算机上,我们使用了C语言编写了一些简单的进程调度算法,并通过模拟不同的进程调度场景进行了实验。
实验内容1. 先来先服务调度算法(FCFS)先来先服务调度算法是一种简单的进程调度算法,它按照进程到达的顺序进行调度。
在本次实验中,我们编写了一个简单的FCFS调度算法,并通过模拟多个进程同时到达的情况,观察其对系统性能的影响。
2. 短作业优先调度算法(SJF)短作业优先调度算法是一种根据进程执行时间长度进行调度的算法。
在本次实验中,我们编写了一个简单的SJF调度算法,并通过模拟不同长度的进程,观察其对系统性能的影响。
3. 时间片轮转调度算法(RR)时间片轮转调度算法是一种按照时间片大小进行调度的算法。
在本次实验中,我们编写了一个简单的RR调度算法,并通过模拟不同时间片大小的情况,观察其对系统性能的影响。
实验结果通过实验,我们发现不同的进程调度算法对系统性能有着不同的影响。
在FCFS 算法下,长作业会导致短作业等待时间过长;在SJF算法下,长作业会导致短作业饥饿现象;而RR算法则能够较好地平衡不同进程的执行。
因此,在实际应用中,需要根据具体情况选择合适的进程调度算法。
结论本次实验通过对进程调度算法的实验,深入理解了不同的进程调度算法对系统性能的影响,并掌握了进程调度算法的实现方法。
同时,也加深了对操作系统的理解,为今后的学习和研究打下了良好的基础。
操作系统实验报告进程调度

操作系统实验报告进程调度操作系统实验报告:进程调度引言操作系统是计算机系统中最核心的软件之一,它负责管理和调度计算机的资源,提供良好的用户体验。
在操作系统中,进程调度是其中一个重要的功能,它决定了进程的执行顺序和时间片分配,对于提高计算机系统的效率和响应能力至关重要。
本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。
一、进程调度的概念进程调度是操作系统中的一个重要组成部分,它负责决定哪个进程可以使用CPU,并为其分配执行时间。
进程调度的目标是提高系统的吞吐量、响应时间和公平性。
在多道程序设计环境下,进程调度需要考虑多个进程之间的竞争和协作,以实现资源的合理利用。
二、进程调度算法1. 先来先服务调度(FCFS)先来先服务调度算法是最简单的进程调度算法之一,它按照进程到达的顺序进行调度,即先到达的进程先执行。
这种算法的优点是公平性高,缺点是无法适应长作业和短作业混合的情况,容易产生"饥饿"现象。
2. 最短作业优先调度(SJF)最短作业优先调度算法是根据进程的执行时间来进行调度的,即执行时间最短的进程先执行。
这种算法的优点是能够最大程度地减少平均等待时间,缺点是无法适应实时系统和长作业的情况。
3. 时间片轮转调度(RR)时间片轮转调度算法是一种抢占式调度算法,它将CPU的执行时间划分为固定大小的时间片,并按照轮转的方式分配给各个进程。
当一个进程的时间片用完后,它将被挂起,等待下一次调度。
这种算法的优点是能够保证每个进程都能够获得一定的执行时间,缺点是无法适应长作业和短作业混合的情况。
4. 优先级调度(Priority Scheduling)优先级调度算法是根据进程的优先级来进行调度的,优先级高的进程先执行。
这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度,缺点是可能会导致低优先级的进程长时间等待。
三、实验结果与分析在实验中,我们使用了不同的进程调度算法,并对其进行了性能测试。
进程调度实验报告

进程调度实验报告一、实验目的。
本实验旨在通过对进程调度算法的模拟和实验,加深学生对进程调度原理的理解,掌握各种进程调度算法的特点和应用场景,提高学生的实际操作能力和分析问题的能力。
二、实验环境。
本次实验使用了C语言编程语言,通过模拟实现了先来先服务(FCFS)、最短作业优先(SJF)、时间片轮转(RR)和多级反馈队列(MFQ)四种进程调度算法。
三、实验过程。
1. 先来先服务(FCFS)调度算法。
先来先服务调度算法是一种非抢占式的调度算法,按照进程到达的先后顺序进行调度。
在本次实验中,我们通过模拟多个进程到达并排队等待CPU执行,观察其平均等待时间和平均周转时间。
实验结果表明,先来先服务调度算法适用于作业长度差异较大的情况,但容易产生“饥饿”现象。
2. 最短作业优先(SJF)调度算法。
最短作业优先调度算法是一种非抢占式的调度算法,按照作业执行时间的长短进行调度。
在本次实验中,我们通过模拟多个作业的执行时间,观察其平均等待时间和平均周转时间。
实验结果表明,最短作业优先调度算法能够最大程度地减少平均等待时间,但可能会导致长作业被“饿死”。
3. 时间片轮转(RR)调度算法。
时间片轮转调度算法是一种抢占式的调度算法,每个进程被分配一个时间片,当时间片用完后,该进程被放到队尾等待。
在本次实验中,我们通过模拟多个进程的执行和时间片的调度,观察其平均等待时间和平均周转时间。
实验结果表明,时间片轮转调度算法能够保证每个进程都能得到一定的执行时间,但可能会导致上下文切换频繁。
4. 多级反馈队列(MFQ)调度算法。
多级反馈队列调度算法是一种综合性的调度算法,根据进程的优先级和执行时间进行动态调整。
在本次实验中,我们通过模拟多个进程的执行和不同优先级队列的调度,观察其平均等待时间和平均周转时间。
实验结果表明,多级反馈队列调度算法能够兼顾短作业和长作业,提高了系统的整体性能。
四、实验总结。
通过本次实验,我们深入理解了不同进程调度算法的特点和适用场景。
《操作系统》上机实验报告—进程调度

《操作系统》上机实验报告实验算法主体内容及#include<stdio.h>#include<dos.h>#include<stdlib.h>#include<conio.h>#include<iostream.h>#define P_NUM 5 // 共有5 个进程#define P_TIME 50 //作为优先数计算时所用的值enum state{ready,execute,block, finish};//进程的状态,使用枚举struct pcb{char name[4]; // 进程名称int priority; //进程优先级int cputime; //已经占有cpu运行的时间int needtime; //还需要运行的时间int count; //在时间片轮转法中使用的int round; //在时间片轮转法中使用的state process; //进程的状态pcb *next; //指向下一个进程的pcb};pcb *get_process() //通过输入各进程的值来建立pcb队列,并返回其首元素的指针{pcb *q;pcb *t;pcb *p;int i=0;coutvv"请输入进程名与时间"<<endl;while(i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name; cin>>q->needtime; q->cputime=O;q->priority=P_TIME-q->needtime;q->round=0; q->count=0;q->process=ready;q->next=NULL;if (i==0){p=q;t=q;}else{ t->next=q; t=q; } i++;}return p;}void display(pcb *p) //显示本轮运行后的进程各状态情况{coutvv" 进程各状态情况"vvendl;coutvv"名称"vv" "vv"进入时间"vv" "vv"还需时间"vv" "vv"优先级"vv" "vv"状态"vvendl;while(p){coutvvp->name;coutvv" ";coutvvp->cputime;coutvv" ";coutvvp->needtime;coutvv" ";cout<vp_>priority;coutvv"";switch(p->process) //对枚举类型的输出方法{case ready:cout< <"就绪"<<endl;break;case execute:cout< <"执行"<<endl;break;case block:cout<<"阻塞"<<endl;break;case finish:cout<<"完成"<<endl;break;} p=p->next;}}int process_finish(pcb *q) //判断所有的进程是否运行结束{ -int b=1;while(q&&b){b=b&&q->needtime==O; q=q_>next;} return b;}void cpuexe(pcb *q) //优先级调度算法的一次执行{pcb *t;t=q;int i=0;while(q){if (q->process!=finish){q_>process=ready;if(q->needtime==0) q->process=finish;} if(i<q->priority) if(q->process!=finish){ t=q;i=q->priority;} q=q->next;}t->needtime-=1;t_>priority_=3; if(t->needtime==0)t->process=finish; t->cputime+=1;}void priority_cal() //优先级调度算法{pcb *p;P=get_process();〃取得进程队列int cpu=0;while(!process_finish(p)) //若进程并未全部结束,则还需要执行{cpu++;coutvv"运行次数:"vvcpuwendl; cpuexe(p);//一次cpu的执行display(p);//显示本次执行结果}}pcb * get_process_round()Jpcb *q;pcb *t;pcb *p;int i=0;coutvv"请输入进程名与时间"《endl;while (i<P_NUM){q=(struct pcb *)malloc(sizeof(pcb));cin>>q->name;cin>>q->needtime; q->cputime=O;q->round=0;q->count=0;q_>process=ready; q->next=NULL; if(i==0){p=q;t=q;}else{} i++; } return p;} t->next=q; t=q;void cpu_round(pcb *q){-q->count++;q->cputime+=2;q->needtime-=2;if(q->needtime<0)q->needtime=0;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){} return t; t=head;while (t->next!=k && t->process==finish) {t=t->next;}void set_state(pcb *p){-while(p){if (p->needtime==O){p->process=finish;}if (p->process==execute){p_>process=ready;} p=p_>next;}}void display_round(pcb *p){ -cout«" 进程各状态情况"vvendl;coutvv"名称"vv" "vv"进入时间"vv" "vv"还需时间"vv" "vv"时间片"vv"" vv"次数"vv""vv"状态"vvendl;while(p){coutvvp->name;coutvv" ";coutvvp->cputime;coutvv" ";coutvvp->needtime;coutvv" ";coutvvp->round;coutvv"";coutvvp->count;coutvv"";switch(p->process){case ready:coutv v"就绪"vvendl;break;case execute:coutvv'执行"vvendl;break;case finish:coutvv"完成"vvendl;break;}p=p->next;}}void round_cal(){pcb *p;pcb *r;p=get_process();int cpu=0;r=p;while(!process_finish(p)){cpu+=2;cpu_round(r);r=get_next(r,p);coutvv"运行次数"vvcpuvvendl;display_round(p);set_state(p);} }-void display_menu(){ -coutvv"进程调度算法操作:"vvendl;coutvv"1 优先数"vvendl;coutvv"2 时间片轮转"vvendl;coutvv"3 退出"vvendl;}void main(){display_menu();int k;printf("请选择:");scanf("%d",&k);switch(k){case 1:priority_cal();break;case 2:round_cal();break;case 3:break;}} ----------------------------------------------------------------------------------------------------------测试数据:¥间出择1A.时退选r 5642 3込簷运行结果:1优先数S却曰石石<奪--a S 亠 亡疋出尢尤扫 亡、 ^a ^T B a 抄各时 各时 进还进还称进入时|可0 3 0I! IS 运行次数 “称进入时间II态成養成成忧完就完完完&0 94 2R p f c 32 3 4 3 % 扰冋运行次数心 泊称进入吋冋R5 R 5 C4 卜2佳行次数陰态成成成成成状§_f c s ^H Z B6 4 28尸尤32 3 4结果截图与分析2、时间片轮转10 0名称进入时问64 42 运行次数t k 称进入吋间A称进入时间竇鶴躺翻聶s _^->4p 者者者奁廿者_J-^□者者HiH8 数 謝还轎時 0 00 0 0次数0 口2 1 21 2 3 3216 6 42 2 1 20 Q 0D F次数3 E34 4 1 1 e s 02 0 0态成成态成衣成成些兀执完lla兀。
实验进程调度的实验报告

一、实验目的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("无效的调度算法选择。
进程调度算法 实验报告

进程调度算法实验报告
《进程调度算法实验报告》
一、实验目的
本实验旨在通过对进程调度算法的实验研究,探究不同调度算法对系统性能的影响,进一步加深对操作系统进程调度的理解。
二、实验内容
本次实验选择了三种常见的进程调度算法,包括先来先服务(FCFS)、最短作业优先(SJF)和轮转调度(RR),并通过模拟不同进程的到达时间和执行时间,分别对这三种算法进行实验比较。
三、实验步骤
1. 设计实验用例:确定不同进程的到达时间和执行时间,以及不同调度算法的时间片大小。
2. 模拟执行:根据设计的实验用例,使用模拟工具模拟不同调度算法的执行过程,并记录每个进程的执行情况和系统的运行情况。
3. 数据分析:根据实验结果,对比不同调度算法的平均等待时间、平均周转时间等指标,分析各算法的优缺点。
四、实验结果
通过实验比较,得出以下结论:
1. 先来先服务(FCFS)算法:适用于执行时间较短的进程,但容易导致长作业等待时间过长。
2. 最短作业优先(SJF)算法:能够最大程度地减少平均等待时间和平均周转时间,但无法处理长作业优先的情况。
3. 轮转调度(RR)算法:能够保证每个进程都能及时得到执行,但可能导致部分进程的等待时间过长。
五、实验结论
根据实验结果,不同的进程调度算法适用于不同的场景。
在实际应用中,需要根据系统的实际情况和需求选择合适的调度算法,以最大程度地提高系统的性能和效率。
六、实验总结
通过本次实验,加深了对进程调度算法的理解,同时也了解了不同算法在实际应用中的优缺点。
希望通过本次实验,能够为进程调度算法的研究和应用提供一定的参考和借鉴。
操作系统实验报告-进程调度实验

进程调度实验一.实验目的及要求:进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。
重复以上过程,直到所要进程都完成为止。
二 . 实验环境:操作系统:Windows XP编译环境:Visual C++ 6.0三.算法描述进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。
就绪进程获得CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后,进程的已占用CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。
重复以上过程,直到所要进程都完成为止。
四. 实验步骤:1.、进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。
对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间。
2、程序源码结构:struct pcb { /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;sort(){…} /* 建立对进程进行优先级排列函数*/ check(){…} /* 建立进程查看函数*/input(){…} /* 建立进程控制块函数*/main() /*主函数*/{...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 resume......");ch=getchar();}printf("\n\n finished.\n");ch=getchar();}3.、实验截图:简单轮转法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)进程调度过程的结果:六、实验总结通过本实验使我对进程的相关概念及进程的优先数调度算法有了更深的理解,使自己在程序设计及编制方面也有了一定的提高。
进程调度实验报告

进程调度实验报告进程调度实验报告一、引言进程调度是操作系统中重要的一个组成部分,它负责管理和分配系统资源给不同的进程,以实现系统的高效运行。
本次实验旨在通过实际操作和观察,深入理解进程调度算法的原理和应用。
二、实验目的1. 理解进程调度的概念和作用;2. 掌握常见的进程调度算法;3. 分析不同调度算法的优缺点。
三、实验环境本次实验使用的是Linux操作系统,并通过编写C语言程序来模拟进程的创建和调度过程。
四、实验过程1. 创建进程在实验开始时,我们首先编写了一个简单的C程序,用于创建多个进程。
通过调用系统函数fork(),我们可以实现进程的复制和创建。
在实验中,我们创建了5个子进程,并分别给它们设置了不同的优先级。
2. 进程调度算法的实现为了模拟不同的进程调度算法,我们在程序中实现了以下几种常见的调度算法:- 先来先服务(FCFS):按照进程到达的先后顺序进行调度,即先到先服务。
- 短作业优先(SJF):按照进程的执行时间进行排序,优先调度执行时间最短的进程。
- 优先级调度:按照进程的优先级进行排序,优先调度优先级最高的进程。
- 时间片轮转调度:将CPU时间分成若干个时间片,每个进程在一个时间片内执行,超过时间片后,将CPU让给下一个进程。
3. 实验结果分析通过运行程序,我们观察到不同调度算法下进程的执行情况,并进行了分析。
- 在先来先服务算法下,进程按照到达的先后顺序进行调度,执行时间较长的进程可能会导致其他进程的等待时间增加。
- 在短作业优先算法下,执行时间短的进程会被优先调度,可以减少平均等待时间,但可能会导致长作业的饥饿。
- 在优先级调度算法下,优先级高的进程会被优先调度,但如果优先级设置不合理,可能会导致低优先级进程长时间等待。
- 在时间片轮转调度算法下,每个进程被分配一个时间片,可以保证每个进程公平地获得执行机会,但如果时间片过小,会导致频繁的上下文切换。
五、实验总结通过本次实验,我们深入了解了进程调度的原理和应用。
进程调度算法实验报告

实验报告实验一:进程调度算法一、实验目的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.模拟批处理多道操作系统的进程调度;2.模拟实现同步机构避免并发进程执行时可能与时间相关的错误;二、实习目的进程调度时进程管理的主要内容之一,通过设计,编制,调试一个简单的进程调度模拟系统,对进程调度,进程运行状态变换及PV操作加深理解和掌握。
三、实习题目采用剥夺式优先算法,对三个进程进行模拟调度模拟PV操作同步机构,用PV操作解决进程进入临界区的问题。
【提示】(1)对三个进程进行模拟调度,对各进程的优先数静态设置,P1,P2,P3三个进程的优先数为1,2,3,并指定P1的优先数最高,P3的优先数最低,每个进程都处于执行态“e”,就绪态“r”,等待态“w”三种状态之一,并假定初始态为“r”。
(2)每一个进程用一个PCB表,PCB表的内容根据具体情况设置,该系统在运行过程中能显示或打印各进程和参数的变化情况,以便观察各进程的调度。
(3)在完成必要的初始化后,便进入进程调度程序,首先由P1进入执行,当执行进程因等待某各事件被阻塞或唤醒某个进程等待进程时,转进程调度。
(4)在进入临界区前后,调PV操作。
(5)如果被唤醒的进程优先数高于现有执行的进程,则剥夺现行进程的执行权。
(6)当三个进程都处于等待状态时,本模拟系统退出执行。
四、示例1.数据结构:(1)进程控制块PCBstruct{int id;char status;int priority;int waiter1;}(2)信号量struct{int value;int waiter2;}sem[2](3)现场保护栈stackchar stack[11][4]每个进程都有一个大小为10个字的现场保护栈,用来保护被中断时的断点地址等信息。
(4)全局变量int i;用以模拟一个通用寄存器char addr;用以模拟程序计数器int m1,m2;为系统设置的公用数据被三个进程共享使用。
五、程序框图:六、程序说明:本程序是用C语言编写,模拟三个进程的运行情况,过程在运行中要调用P操作申请信号量,如果该过程得到其申请的信号量,就继续运行,否则P操作阻塞该申请过程的运行,并将过程置为所申请信号量的等待者,如果已有其它过程在等待同一信号量则将该申请过程排在所有等待进程之后。
进程调度实验报告

进程调度实验报告引言:进程调度是操作系统中一个重要的概念,它决定了一个进程何时开始执行、何时暂停、何时唤醒等等。
一个良好的进程调度算法可以提高系统的效率和响应时间。
在这次实验中,我们将对不同的进程调度算法进行测试和对比分析,旨在探究不同算法对系统性能的影响。
实验步骤:1. 实验准备在实验开始前,我们需要准备一个充分复杂的测试环境,包括不同类型的进程、不同进程的优先级、进程执行时间等参数。
这些参数的设置将影响我们对不同调度算法的评估。
2. 先来先服务调度算法(FCFS)先来先服务调度算法是最简单的一种调度算法,按照进程到达CPU的顺序依次执行。
在这个实验中,我们首先对先来先服务调度算法进行测试。
结果显示,对于短时进程,FCFS算法效果较好,但在遇到长时进程时,会出现“饥饿”现象,易导致优先级较低的进程无法获得CPU时间。
3. 短作业优先调度算法(SJF)短作业优先调度算法根据进程执行时间的长短来进行调度。
在实验中,我们通过设置不同长度的进程来对SJF算法进行测试。
结果显示,SJF算法能够较好地避免“饥饿”现象,但如果长作业在一个时间片内到达,就会导致短作业等待时间过长。
4. 优先级调度算法(Priority)优先级调度算法通过为每个进程指定一个优先级来进行调度,优先级高的进程先执行。
在实验中,我们设置不同优先级的进程,测试Priority算法的效果。
结果显示,Priority算法能够合理地根据优先级分配CPU时间,但如果优先级的划分不合理,可能导致某些进程优先级一直很低,影响整体系统性能。
5. 时间片轮转调度算法(Round Robin)时间片轮转调度算法是一种较为公平的调度算法,每个进程被分配一个时间片,在时间片用完后,进程暂停执行,并被放置于“就绪队列”尾部,等待下一个时间片。
在测试中,我们可以通过设置不同的时间片长度来观察时间片轮转算法的效果。
结果显示,时间片轮转算法能够较好地平衡进程的等待时间和执行时间。
进程调度实验报告

进程调度实验报告进程调度实验报告一、实验目的本实验旨在通过模拟进程调度算法,加深对操作系统进程调度的理解,掌握进程调度算法的实现方法。
二、实验环境操作系统:Windows 10编程语言:C++开发工具:Visual Studio 2019三、实验内容1. 实现进程调度算法本实验实现了三种进程调度算法:先来先服务(FCFS)、短作业优先(SJF)和时间片轮转(RR)。
其中,FCFS算法按照进程到达的先后顺序进行调度,SJF算法按照进程执行时间的长短进行调度,RR算法则按照时间片轮转的方式进行调度。
2. 模拟进程调度过程本实验模拟了多个进程的调度过程,包括进程的创建、调度、执行和结束。
在模拟过程中,每个进程都有自己的进程ID、到达时间、执行时间和优先级等属性。
通过模拟进程调度过程,可以更好地理解进程调度算法的实现原理。
3. 统计调度结果本实验统计了每种进程调度算法的平均等待时间、平均周转时间和平均带权周转时间。
通过统计调度结果,可以比较不同进程调度算法的优劣,为实际应用提供参考。
四、实验结果1. 进程调度算法的实现本实验实现了三种进程调度算法,分别是FCFS、SJF和RR。
其中,FCFS算法的实现比较简单,只需要按照进程到达的先后顺序进行调度即可。
SJF算法则需要根据进程的执行时间进行排序,然后按照排序后的顺序进行调度。
RR算法则需要设置时间片大小,每个进程执行一个时间片后,将其放入就绪队列的末尾,然后轮到下一个进程执行。
2. 模拟进程调度过程本实验模拟了多个进程的调度过程,包括进程的创建、调度、执行和结束。
在模拟过程中,每个进程都有自己的进程ID、到达时间、执行时间和优先级等属性。
通过模拟进程调度过程,可以更好地理解进程调度算法的实现原理。
3. 统计调度结果本实验统计了每种进程调度算法的平均等待时间、平均周转时间和平均带权周转时间。
通过统计调度结果,可以比较不同进程调度算法的优劣,为实际应用提供参考。
2021年操作系统进程调度实验报告

试验一进程调度试验专业: XXXXX学号: XXXXX姓名: XXX试验日期: 20XX年XX月XX日一、 试验目经过对进程调度算法模拟加深对进程概念和进程调度算法了解。
二、 试验要求编写程序实现对5个进程调度模拟, 要求最少采取两种不一样调度算法分别进行模拟调度。
三、 试验方法内容1. 算法设计思绪将每个进程抽象成一个控制块PCB, PCB 用一个结构体描述。
构建一个进程调度类。
将进程调度多种算法分装在一个类中。
类中存在三个容器, 一个保留正在或未进入就绪队列进程, 一个保留就绪进程, 另一个保留已完成进程。
还有一个PCB 实例。
关键保留正在运行进程。
类中其她方法都是围绕这三个容器能够这个运行中PCB 展开。
关键用到技术是STL 中vector 以维护和保留进程容器、 就绪容器、 完成容器。
当程序开启时, 用户能够选择不一样调度算法。
然后用户从控制台输入各个进程信息, 这些信息保留到进程容器中。
进程信息输入完成后, 就开始了进程调度, 每调度一次判定就绪队列是否为空, 若为空则系统时间加一个时间片。
判定进程容器中是否有新进程能够加入就绪队列。
2. 算法步骤图 主程序框架:();//先来先服务();//最短进程优先调度//简单时间片轮转//最高优先数优先.m_WaitQueue .empty ()||.m_ProcessQueue .empt ()();//输入进程信息();();进程调度过程:;3.算法中用到数据结构struct fcfs{ //先来先服务算法从这里开始char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float dqzztime;}; //定义一个结构体, 里面包含有一个进程相关信息4.关键常量变量vector<PCB>m_ProcessQueue;//进程输入队列vector<PCB>m_WaitQueue;//进程就绪队列vector<PCB>m_FinishQueue;//完成队列vector<PCB>::iterator m_iter;//迭代器PCB m_runProcess;//运行中进程int m_ProcessCount;//进程数float m_RunTime;//运行时间int m_tagIsRun;//是否在运行标志。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验2、1 进程调度一、 实验目的多道程序设计中,经常就是若干个进程同时处于就绪状态,必须依照某种策略来决定那个进程优先占有处理机。
因而引起进程调度。
本实验模拟在单处理机情况下的处理机调度问题,加深对进程调度的理解。
二、 实验要求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)输入:进程流文件(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进程5 3 8 7输出: 进程执行流等待时间,平均等待时间本程序包括:FIFO 算法,优先数调度算法,时间片轮转调度算法产生n 个进程,的时间片数,已占用CPU 的时间片数置为0 按进程产生的先后次序拉成就绪队列链=0? 撤销该进程就绪队列为空不? =轮转时间片数?NY YY 结束 N(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<<" "<<pcbs[i]、status<<" "<<pcbs[i]、time<<" "<<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即可得出以下输出结果:。