下载文档原格式
操作系统实验报告实验二时间片轮转进程调度算法学号：班级：姓名:【实验题目】: 时间片轮转进程调度算法【实验目的】通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略与对系统性能的评价方法。
【实验内容】问题描述:设计程序模拟进程的时间片轮转RR 调度过程。
假设有n 个进程分别在T1, … ,Tn 时刻到达系统, 它们需要的服务时间分别为S1, … ,Sn 。
分别利用不同的时间片大小q, 采用时间片轮转RR 进程调度算法进行调度, 计算每个进程的完成时间, 周转时间和带权周转时间, 并且统计n 个进程的平均周转时间和平均带权周转时间。
程序要求如下:1）进程个数n ；每个进程的到达时间T 1, … ,T n 和服务时间S 1, … ,S n ；输入时间片大小q 。
2）要求时间片轮转法RR 调度进程运行, 计算每个进程的周转时间, 带权周转时间, 并且计算所有进程的平均周转时间, 带权平均周转时间；3）输出: 要求模拟整个调度过程, 输出每个时刻的进程运行状态, 如“时刻3: 进程B开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间, 带权周转时间, 所有进程的平均周转时间, 带权平均周转时间。
实现提示:用C++语言实现提示:1）程序中进程调度时间变量描述如下:int ArrivalTime[100];int ServiceTime[100];int PServiceTime[100];int FinishTime[100];int WholeTime[100];double WeightWholeTime[100];double AverageWT,AverageWWT;bool Finished[100];➢2）进程调度的实现过程如下:➢变量初始化；➢接收用户输入n, T1, … ,Tn, S1, … ,Sn；时间片大小q；➢按照时间片轮转RR算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间；➢计算所有进程的平均周转时间和平均带权周转时间；➢按格式输出调度结果。
时间片轮转调度算法实验时间片轮转调度算法是一种基于时间片轮转的进程调度算法，它按照轮转的方式，将每个进程分配一个时间片，如果该进程在时间片结束前未完成其任务，则该进程将被挂起，然后下一个进程继续执行。
下面将从实验过程、结果分析和算法优缺点三个方面回答该问题。
实验过程：本次实验使用C语言编写程序，模拟了一个简单的时间片轮转调度算法。
实验环境为Windows 10操作系统，使用了Dev-C++ 5.11编译器。
实验流程如下：1.首先定义了一个进程的结构体，其中包括了进程的名称、进程需要执行的时间片以及已经执行的时间片。
2.定义一个队列来存储进程，为了方便起见，队列采用了循环存储结构。
3.在主函数中，首先输入需要执行的进程数和一个时间片长度，接着依次输入每个进程的名称和需要执行的时间。
程序会根据输入的信息初始化进程，并将进程加入队列。
4.最后，程序开始模拟调度器的调度过程。
每次从队列中取出一个进程，将其执行时间减去一个时间片。
如果执行时间为0，则代表该进程已经完成任务，将其移出队列。
如果执行时间大于0，则将该进程重新加入队列尾部，然后下一个进程开始执行。
结果分析：在进行实验的过程中，我们发现时间片轮转调度算法可以很好地实现多进程的调度。
通过不断地轮转时间片，每个进程都有机会被执行。
此外，该算法具有良好的响应时间和公平性，能够确保每个进程都能够在一定时间内执行一定的任务，从而提高了系统的利用率和效率。
算法优缺点：时间片轮转调度算法具有以下几个优点：1. 公平性：每个进程都能够在一定时间内获得相同的可执行时间。
2. 可控性：时间片长度可以根据需要自行改变。
3. 高效性：可以很好地支持多进程的调度，提高了系统的利用率和效率。
同时，该算法也存在一些缺点：1.时间片的长度可能对进程的执行效率产生影响，长度过长会导致进程轮转过于缓慢，降低了系统的响应速度，长度过短则会增加进程上下文切换的次数。
2. 由于算法本身的局限性，它可能无法解决一些与进程先后顺序等有关的问题，例如死锁或者资源争用等。
时间片轮转调度例题时间片轮转调度算法是一种进程调度算法，它根据进程到达时间的先后排序，给每个进程分配一个时间片，然后在时间片内让进程运行，直到时间片用完为止。
时间片的大小通常是固定的，并且是进程运行时间的一半。
下面是一个时间片轮转调度算法的例题:假设有五个进程 P1、P2、P3、P4、P5，它们的到达时间分别为: - P1:2023 年 2 月 18 日 10:00:00- P2:2023 年 2 月 18 日 10:30:00- P3:2023 年 2 月 18 日 11:00:00- P4:2023 年 2 月 18 日 11:30:00- P5:2023 年 2 月 18 日 12:00:00假设每个进程都需要相同的时间才能完成任务，即每个进程的运行时间都是 3 小时。
现在需要对这些进程进行调度，并安排它们的执行顺序。
为了进行时间片轮转调度，需要将每个进程的到达时间转换为当前时间，然后按照到达时间的先后顺序排序。
例如，P1 的到达时间是 2023 年 2 月 18 日 10:00:00，将其转换为当前时间为 2023 年2 月 18 日 10:00:00。
排序后，可以按照以下步骤安排进程的执行顺序:1. 将 P1 排在第一位，因为它的到达时间最早。
2. 将 P2 排在 P1 的后面，因为它的到达时间比 P1 晚 30 分钟。
3. 将 P3 排在 P2 的后面，因为它的到达时间比 P2 晚 30 分钟。
4. 将 P4 排在 P3 的后面，因为它的到达时间比 P3 晚 30 分钟。
5. 将 P5 排在 P4 的后面，因为它的到达时间比 P4 晚 30 分钟。
根据上述排序，可以得到以下执行顺序:- P1:2023 年 2 月 18 日 10:00:00- P2:2023 年 2 月 18 日 10:30:00- P3:2023 年 2 月 18 日 11:00:00- P4:2023 年 2 月 18 日 11:30:00- P5:2023 年 2 月 18 日 12:00:00因此，按照时间片轮转调度算法，P1 首先执行，然后依次轮到 P2、P3、P4、P5 执行。
题目4基于优先数的时间片轮转调度算法调度处理器一、实验目的在采用多道程序设计的系统中，同时处于就绪态的进程往往有多个，当就绪态的进程数大于处理器的个数时，就需按照某种策略进行分配处理器。
本次设计模拟在单处理器情况下采用基于优先数的时间片轮转调度算法进行处理器调度，加深了解处理器调度工作过程。
二、实验内容及要求1、设计一个程序实现基于优先数的时间片轮转调度算法调度处理器。
2、假定系统有5个进程，每个进程用一个进程控制块PCB开代表，进程控制块的结构如下图所示：图1其中：进程名：作为进程的标识。
指针：进程按顺序排成循环链表，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针指出第一个进程的进程控制块首地址。
要求运行时间：假设进程需要运行的单位时间数。
已运行时间：假设进程已经运行的单位时间数，初值为0。
状态：可假设有两种状态，就绪状态和结束状态。
进程的初始状态都为就绪状态。
3、每次运行所设计的处理器调度程序调度进程之前，为每个进程任意确定它的要求运行时间。
4、此程序是模拟处理器调度，因此，被选中的进程并不实际启动运行，而是执行已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位时间。
.5、在所设计的程序中应有显示或打印语句，能显示或打印每次被选中的进程名以及运行一次后进程队列的变化。
6、为进程任意确定要求运行时间，运行所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。
7、设有一个就绪队列，就绪进程按优先数（优先数范围0－100）由小到大排列（优先数越小，级别越高）。
当某一进程运行完一个时间片后，其优先级应下调（如优先数加2或3）。
8、例如一组进程如下表：三、实验报告1、程序中使用的数据结构及符号说明。
2、给出主要算法的流程图3、给出程序清单并附上注释4、打印程序运行时的初值和运行结果。
（运行一个进程输出一次结果）三、实验代码#include<>#include<>#include<>#define getpch(type) (type*)malloc(sizeof(type)) d:\n",i);printf("\n请输入作业的名字:");scanf("%s",l->name);printf("\n请输入作业的时间:");scanf("%d",&l->need_time);l->state = 'r'; d:\n",i);printf("\n请输入作业的名字:");scanf("%s",p->name);printf("\n请输入作业的时间:");scanf("%d",&p->need_time);p->state='r';p->worked_time=0;p->flag=0;l->link=p;l=l->link;}rear=l;rear->link=front;}void output().\n");getch();}if(s->state=='e'&&s->flag==0){printf("进程%s已经运行完成！\n\n",s->name);s->flag=1;}s=s->link;flag1=judge(s);}printf("--------------------------------------------\n"); }void input(){int i,num;printf("\n 请输入作业的个数:");scanf("%d",&num);for(i=0;i<num;i++){printf("\n 作业号No.%d:\n",i); p=getpch(JCB);printf("\n 输入作业名:");scanf("%s",p->name);printf("\n 输入作业到达时刻:"); scanf("%f",&p->subtime);printf("\n 输入作业运行时间:"); scanf("%f",&p->runtime);printf("\n");p->state='w';p->link=NULL;sort();}}int space(){int l=0; JCB* jr=ready;while(jr!=NULL){l++;jr=jr->link;}return(l);}void disp(JCB* jr,int select){if (select==3) printf("\n 作业到达时间服务时间响应比运行时刻完成时刻周转时间带权周转时间\n");else printf("\n 作业到达时间服务时间运行时刻完成时刻周转时间带权周转时间\n");printf(" |%s\t",jr->name);printf(" |%.2f\t ",jr->subtime);printf(" |%.2f\t",jr->runtime);if (select==3&&p==jr) printf("|%.2f ",jr->Rp);if (p==jr){printf("|%.2f\t ",jr->;printf(" |%.2f ",jr->;printf(" |%.2f\t",jr->;printf(" |%.2f",jr->;}printf("\n");}int destroy(){printf("\n 作业[%s] 已完成.\n",p->name);free(p);return(1);}void check(int select){JCB* jr;printf("\n **** 当前正在运行的作业是:%s",p->name); disp(p,select);jr=ready;printf("\n ****当前就绪队列状态为:\n");while(jr!=NULL){jr->Rp=(jr->runtime+T-jr->subtime)/jr->runtime; disp(jr,select);jr=jr->link;}destroy();}void running(JCB* jr){if (T>=jr->subtime) jr->=T;else jr->=jr->subtime;jr->=jr->+jr->runtime;jr->=jr->>subtime;jr->=jr->jr->runtime;T=jr->;}int main(){int select=0,len,h=0;float sumTi=0,sumWi=0;printf("\t---*****************---\n"); printf("请选择作业调度算法的方式:\n"); printf("\ \n\n");printf("\t---*****************---\n"); printf("请输入作业调度算法序号(1-4):"); scanf("%d",&select);if (select==4){ creatJCB();RRget();}else{input();len=space();while((len!=0)&&(ready!=NULL)){h++;printf("\n 执行第%d个作业\n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';running(p);sumTi+=p->;sumWi+=p->;check(select);if (select==2&&h<len-1) SJFget();if (select==3&&h<len-1) HRNget();printf("\n 按任意一键继续......");getchar();getchar();}printf("\n\n 作业已经完成.\n");printf("\t 此组作业的平均周转时间：%.2f\n",sumTi/h);printf("\t 此组作业的带权平均周转时间：%.2f\n",sumWi/h);getchar();} }四、运行结果截图。
时间片轮转调度算法实验报告一、引言时间片轮转调度算法是一种常见的操作系统调度算法，它的主要思想是将CPU时间分成若干个时间片，每个进程在一个时间片内执行一定的时间，然后切换到下一个进程执行。
本实验通过使用C语言模拟实现时间片轮转调度算法，并对其进行评估和比较，以便更好地理解该调度算法的性能和特点。
二、实验目的1.理解时间片轮转调度算法的原理和实现方式；2.实现一个简单的时间片轮转调度算法模拟程序；3.比较时间片长度对调度算法性能的影响；4.分析时间片轮转调度算法的优缺点。
三、实验过程1.设计数据结构和算法在开始实验之前，我们首先需要设计数据结构和算法。
在本实验中，我们使用一个队列来表示就绪队列，并使用一个指针来标记当前执行的进程。
2.实现时间片轮转调度算法模拟程序根据设计的数据结构和算法，我们使用C语言编写了一个简单的时间片轮转调度算法模拟程序。
程序首先会要求用户输入进程数量和每个进程的执行时间，然后根据输入的信息，使用时间片轮转调度算法对进程进行调度并统计各个进程的等待时间和周转时间。
3.进行实验和分析我们进行了多组实验，通过改变时间片的长度，观察时间片轮转调度算法的性能。
并对实验结果进行统计和分析，比较不同时间片长度下的平均等待时间和平均周转时间。
四、实验结果和分析在本节，我们将介绍实验的结果和分析。
1.实验结果我们使用不同时间片长度进行了多组实验，得到了如下的结果：时间片长度，平均等待时间，平均周转时间------------，-------------，-------------1，5，152，3，134，2，128，1，112.结果分析通过对实验结果的分析，我们可以得出以下结论：-随着时间片长度的增加，进程的平均等待时间和平均周转时间都呈现下降的趋势。
这是因为时间片越长，每个进程执行的时间就越长，进程切换的次数就越少，从而提高了系统的效率。
-当时间片长度较小时，进程的平均等待时间和平均周转时间较长。
时间片轮转算法（Round Robin，简称RR）是一种简单而常用的进程调度算法。
该算法按照固定的时间片长度将CPU时间分配给各个进程，当时间片用完时，进程被放到队列末尾，等待下一次调度。
下面是一个简单的RR算法的例子：
假设有三个进程A、B和C，它们的执行时间分别为10、20和30个时间单位。
每个进程在完成其执行时间后结束。
首先，将所有进程的执行时间累加起来得到总执行时间：A + B + C = 10 + 20 + 30 = 60个时间单位。
然后，计算每个进程的执行时间占总执行时间的比例：A = 10/60 = 1/6，B = 20/60 = 1/3，C = 30/60 = 1/2。
接下来，按照比例分配时间片。
假设时间片的长度为X个时间单位，则：
A的执行时间为X * (1/6) = X/6个时间单位；
B的执行时间为X * (1/3) = X/3个时间单位；
C的执行时间为X * (1/2) = X/2个时间单位。
假设时间片长度为5个时间单位，则：
A在第一个时间片内完成，总共需要5/6个时间单位；
B在第二个时间片内完成，总共需要5/3个时间单位；
C在第三个时间片内完成，总共需要5/2个时间单位。
最终，每个进程的完成时间和剩余CPU时间是：
A完成时间为5/6 + 5/3 = 15/6个时间单位；
B完成时间为5/3 + 5/2 = 25/6个时间单位；
C完成时间为5/2 + 5/6 = 40/6个时间单位。
需要注意的是，RR算法可能会导致某些进程等待较长时间，因此在实际应用中需要根据实际情况选择合适的调度算法。
基于优先级的时间片轮转调度算法
基于优先级的时间片轮转调度算法是一种常用的调度算法，它适用于多进程环境下的进程调度。
该算法结合了时间片轮转和优先级调度两种方式，以实现更合理的进程调度。
在该算法中，每个进程都有一个优先级，优先级越高的进程会优先被调度。
同时，每个进程还会被分配一个时间片，时间片决定了进程可以在CPU上运行的时间。
当一个进程的时间片用完后，它会被暂停，等待下一次轮到它的时间片。
此时，优先级更高的进程会抢占CPU，继续执行。
具体来说，基于优先级的时间片轮转调度算法的步骤如下：
1.根据进程的优先级，将进程按照优先级从高到低排
列。
2.将时间片轮转至第一个进程，让其开始执行。
3.当进程执行完分配给它的时间片后，将其暂停，将控
制权交还给系统。
4.如果没有进程结束，则继续执行第2步和第3步，直
到有一个进程结束。
5.当一个进程结束时，将优先级更高的进程加入队列头
部，重新开始执行。
通过以上步骤，基于优先级的时间片轮转调度算法可以实现高优先级的进程优先执行，同时保证了低优先级的进程在时间片用尽后能够公平地共享CPU资源。
操作系统进程调度算法模拟实验进程调度是操作系统中一个重要的功能，它决定了哪些进程能够获得处理器资源以及如何按照一定的策略来分配这些资源。
为了更好地理解进程调度算法的工作原理，我们可以进行一个模拟实验来观察不同算法的表现效果。
实验设想：我们设想有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。
时间片轮转调度算法java可视化模拟程序如何实现一个时间片轮转调度算法的java可视化模拟程序？时间片轮转调度算法是操作系统中常用的一种调度算法，它可以确保所有进程公平并且均衡地使用CPU资源。
在时间片轮转调度算法中，每个进程被分配一个固定的时间片，在这个时间片内执行，如果时间片用完，进程将被挂起，并将CPU资源分配给下一个进程。
为了更好地理解和学习时间片轮转调度算法，我们可以通过编写一个简单的java可视化模拟程序来模拟这个过程。
下面将一步一步回答如何实现这个模拟程序。
第一步：创建一个进程类我们需要创建一个Process类来表示每个进程。
这个类应该包含以下属性：- 进程ID（唯一标识符）- 进程名称- 进程到达时间- 进程需要的总执行时间- 进程已经执行的时间同时，这个类还应该包含一些方法来获取和修改这些属性的值。
第二步：创建一个调度类我们需要创建一个Scheduler类来模拟时间片轮转调度算法。
这个类应该包含以下属性：- 调度队列（用来存放进程的队列）- 时间片大小- 当前执行的进程同时，这个类还应该包含一些方法来模拟时间片轮转调度算法的执行过程，例如：- 将进程添加到调度队列- 根据时间片大小执行当前进程- 将当前进程挂起并将CPU资源分配给下一个进程第三步：编写可视化界面我们需要创建一个可视化界面来显示进程的执行和调度过程。
我们可以使用Java的图形界面库（如Swing或JavaFX）来实现这个界面。
界面应该包含以下组件：- 一个文本框用来输入进程的信息（进程ID，到达时间，执行时间等）- 一个按钮用来添加进程到调度队列- 一个文本框用来显示当前正在执行的进程信息- 一个文本框用来显示调度队列中的进程信息- 一个文本框用来显示每个进程的执行情况（已经执行的时间，还需要执行的时间等）- 一个按钮用来开始模拟时间片轮转调度算法的执行过程第四步：实现模拟程序的逻辑在可视化界面中，当用户点击“添加进程”按钮时，应该将进程添加到调度队列中。
c语言实现基于时间片轮转调度算法以下是基于时间片轮转调度算法的C语言实现示例：```c#include <stdio.h>#include <stdlib.h>typedef struct Process {int pid; // 进程IDint burstTime; // 执行时间int remainingTime; // 剩余执行时间int arrivalTime; // 到达时间int waitingTime; // 等待时间} Process;void timeSliceScheduling(Process processes[], int n, int timeSlice) {int currentTime = 0;int completedProcesses = 0;while (completedProcesses < n) {for (int i = 0; i < n; i++) {if (processes[i].remainingTime > 0) {int executionTime = (processes[i].remainingTime > timeSlice) ? timeSlice : processes[i].remainingTime;processes[i].remainingTime -= executionTime;currentTime += executionTime;if (processes[i].remainingTime == 0) {completedProcesses++;processes[i].waitingTime = currentTime - processes[i].arrivalTime - processes[i].burstTime;}}}}}void printWaitingTime(Process processes[], int n) { printf("Process\tWaiting Time\n");for (int i = 0; i < n; i++) {printf("%d\t%d\n", processes[i].pid, processes[i].waitingTime);}}int main() {int n, timeSlice;printf("Enter the number of processes: ");scanf("%d", &n);Process processes[n];printf("Enter the burst time and arrival time for each process:\n");for (int i = 0; i < n; i++) {processes[i].pid = i + 1;printf("Process %d: ", processes[i].pid);scanf("%d%d", &processes[i].burstTime,&processes[i].arrivalTime);processes[i].remainingTime = processes[i].burstTime;processes[i].waitingTime = 0;}printf("Enter the time slice: ");scanf("%d", &timeSlice);timeSliceScheduling(processes, n, timeSlice);printWaitingTime(processes, n);return 0;}```这个示例演示了如何使用时间片轮转调度算法计算进程的等待时间。
操作系统课程设计报告课程设计题目：基于时间片轮转法调度算法模拟姓名：学号：专业：计算机科学与技术班级：指导教师：小辉2013 年1月11日目录一.课程设计目的与内容 (1)二.任务分析 (2)三.概要分析 (3)四.详细设计 (4)五.运行结果 (6)六.总结 (7)七.附录 (8)八.评分表 (11)一.课程设计目的与内容1.课程设计目的（1）在单处理器情况下按时间片轮转算法实现处理器调度，输出运行动态变化过程。
（2）通过算法的实现加深了解处理器调度的工作。
2.课程设计内容输入实现处理器调度的几个进程信息，任意确定一组“要求运行时间”，启动所设计的处理器调度程序，显示逐次被选中进程的进程名以及进程控制块的动态变化过程。
二、任务分析时间片轮转的主要思想就是按顺序为每一个进程一次只分配一个时间片的时间。
算法要完成的功能就是将各个进程按照时间片轮转运行的动态过程显示出来。
时间片轮转算法的主要实现过程是首先为每一个进程创建一个进程控制块，定义数据结构，说明进程控制块所包含的内容，有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息。
实现的过程即运用指针指向某一个进程，判断当前的进程是否是就绪状态“r”，如果是，则为该进程分配一个时间片，同时，已运行时间加一且要求运行的时间减一，如此循环执行，当某一个进程的所需要运行的时间减少至0时，则将该进程的状态设置为“e”。
然后，将指针指向下一个未运行完成的进程，重复判断，直至所有的进程都运行结束。
三、概要设计（1）所用数据结构及符号说明#include"stdio.h"#include"conio.h"#include"malloc.h"#include"string.h"#define NULL 0typedef struct PCB{char name[10]; //进程名struct PCB *next; //链指针int need_time; //要求运行时间int worked_time; //已运行时间char condition; //进程状态，只有“就绪”和“结束”两种状态int flag; //进程结束标志}PCB;PCB *front,*rear;int N; //N为进程数（2）主程序的流程图：（3）程序说明：处理器调度总是选择指针指示的进程运行。
由于本实验是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，而是执行：已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位的时间。
四、详细设计（1）首先每一个进程用一个进程控制块PCB来代表。
进程控制块的格式为：等。
指针——进程按顺序排成循环链队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程的指针指出第一个进程的进程控制块首地址。
要求运行时间——假设进程需要运行的单位时间数。
已运行时间——假设进程已经运行的单位时间数，初始值为“0”。
状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“r”表示。
当一个进程运行结束后，它的状态为“结束”，用“e”表示。
（2）每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。
（3）程序详细设计步骤：a.首先建立PCB的数据结构，为了便于正确输出，加上了进程结束标志flag。
输入进程信息（包括进程名和要求运行的时间），并为每个进程创建一个PCB 并初始化形成一个循环链队列，用函数creatPCB()来实现。
b.建立函数judge()用来判断进程全部运行结束标志，即当所有进程的状态变为’e’（即完成状态）后，循环结束，表示所有进程都已运行成功。
c.建立时间片轮转算法creatProcess（）对进程进行轮转运行，首先指针s 指向第一个进程PCB，即s=front，判断该进程的状态是否为’r’（就绪状态），即if(s->condition == 'r')，若是则表示此进程尚未执行结束，则执行s->worked_time++且s->need_time--，if(s->need_time==0)，则表示此进程已运行结束，将其状态置为结束，即s->condition='e'，并根据状态位输出完成信息，且以后不会再运行此进程。
将指针指向下个进程，s=s->next，并判断所有进程是否已全部运行结束，没有则重复上面算法。
当所有进程的状态位都变成’e’表示所有进程运行完成，则循环结束。
d.建立主函数main(),输入进程数N，调用初始化循环链队列函数creatPCB()和时间片轮转算法creatProcess(N)，每次选中进程的进程名以及运行一次后进程队列的变化，实现处理器的调度。
五、运行结果六、实验总结在完成时间片轮转算法的实现过程中，我们遇到了一些问题，比如怎样运用循环队列，如何设计结构体等等，也积极配合并思考进行解决。
整体来说，我们的算法虽然实现了体现进程动态运行变化的过程，但是相对而言比较简单。
实验中，我们小组不断讨论对算法进行优化，使得运行结果看起来更容易理解，也达到了处理机调度的功能。
做实验让我们对于时间片轮转的思想理解的更加透彻，巩固了理论知识的学习。
实验心得体会：首先，我们认为这次课程设计是对学习《操作系统》的一次综合考察，锻炼我们综合分析问题、解决问题的能力。
初次得到课程设计的题目时，为程序本身的简单而窃喜过；实验过程中也出现了一些难题需要解决，为此去苦苦探索过。
课程设计期间，几乎有几天我们完全投入进去了，就像是在做一个相当重要的项目一样的感觉。
曾经跑过图书馆几次，只是为了一种新的想法得到实现，也曾多次登录网站浏览网页，为了弥补一些知识上的纰漏，为此曾洒下了真实的汗水。
当我们的想法得到实现，又学会了新的知识的时候，心中满是欣喜，或许这是实践出真知的真实验证，有付出就有回报的真实写照吧。
其次，我们感受了真诚的友谊。
在实验中，遇到的问题是多方面的，而且有那么一部分是以前学过的C问题，但是已经忘却或是以前没有真正的理解过。
但是你会发现就在你的身边，会有那么一批人在背后热心的帮助你，让你身处困境却感到无限希望。
这好像是人生的一种历程，风风雨雨中我们一起走过，然后为了一些坑坑洼洼彼此真诚的帮助过和无私的付出过。
团队的协作和彼此心的交流让我们彼此丰厚起来，这也是我们成长中必不可失的重要部分。
最后，我认识到了自己的不足。
平心而论，以前真的没有认真的学习过，即使是在听课，可是后来却没有对学习中出现的问题而仔细分析过。
得过且过，迷失了我前进的方向，而现在却又重新敞开了。
不论是以后的学习还是工作，我想这都是很重要的，我们需要不断进步的动力。
七、附录实验源程序如下：#include"stdio.h"#include"conio.h"#include"malloc.h"#include"string.h"#define NULL 0typedef struct PCB{char name[10]; //进程名struct PCB *next; //链指针int need_time; //要求运行时间int worked_time; //已运行时间char condition; //进程状态，只有“就绪”和“结束”两种状态int flag; //进程结束标志}PCB;PCB *front,*rear;int N; //N为进程数void creatPCB(){ //为每个进程创建一个PCB并初始化形成一个循环链队列PCB *p,*l;l = (PCB *)malloc(sizeof(PCB));printf("Please enter process name and time\n");scanf("%s%d",l->name,&l->need_time);l->condition = 'r'; //进程初始状态为就绪l->worked_time = 0;l->next=NULL;l->flag=0;front=l;for(int i = 1;i < N ;i ++){p = (PCB *)malloc(sizeof(PCB));scanf("%s%d",p->name,&p->need_time);p->condition = 'r';p->worked_time = 0;p->flag=0;l->next = p;l=l->next;}rear=l;rear->next=front;}void output(){ //进程输出函数printf("name runtime needtime state\n");for(int j=1;j<=N;j++){printf(" %-4s\t%-4d\t%-4d\t%-c\n",front->name,front->worked_time,front->need_time,front->con dition);front=front->next;}printf("\n");}int judge(PCB *p){ //判断所有进程运行结束int flag = 1;for(int i=0;i<N;i++){if(p->condition != 'e'){flag = 0;break;}p=p->next;}return flag;}void creatProcess(int n){ //时间片轮转算法PCB *s,*p;int i,j,flag1=0;s = (PCB *)malloc(sizeof(PCB));s=front;printf("\n--------------------------------------------\n");output();printf("Press any key to continue...\n\n");getch(); //按任意键继续s=front;while(flag1 != 1){if(s->condition == 'r'){s->worked_time++;s->need_time--;if(s->need_time==0)s->condition='e';output();printf("Press any key to continue...\n\n");getch();}if(s->condition=='e' && s->flag==0){printf("进程%s已经运行完成！\n\n",s->name);s->flag=1;}s=s->next;flag1=judge(s);}printf("--------------------------------------------\n"); }void main(){printf("Please enter process number\n");scanf("%d",&N);;creatPCB();creatProcess(N);}东华理工大学信息工程学院课程设计评分表学生姓名：班级：学号：课程设计题目：基于时间片轮转法调度算法模拟。
