操作系统课程设计时间片轮转算法java实现

实验二间片轮转RR进程调度算法1、实验目的通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

2、试验内容问题描述：设计程序模拟进程的时间片轮转RR调度过程。

假设有n个进程分别在T1, … ,T n时刻到达系统，它们需要的服务时间分别为S1, … ,S n。

分别利用不同的时间片大小q，采用时间片轮转RR进程调度算法进行调度，计算每个进程的完成时间、周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。

3、程序要求：1）进程个数n；每个进程的到达时间T1, … ,T n和服务时间S1, … ,S n；输入时间片大小q。

2）要求时间片轮转法RR调度进程运行，计算每个进程的周转时间和带权周转时间，并且计算所有进程的平均周转时间和带权平均周转时间；3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

4、需求分析(1) 输入的形式和输入值的范围时间片真实进程数各进程的到达时间各进程的服务时间(2) 输出的形式模拟整个调度过程、周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。

（3）测试用例5、调试分析由于自己自编写代码方面与他人有一定的差距，因此在做实验的过程中我在网上搜了很多相关的资料，了解实现该算法的原理及各部分实现的代码，同时参考了几个别人写好的源代码，然后自己在理解的基础上不断的根据要求修改写程序，不过其中碰见的很多的问题。

我已经自己调了好多错误，在一遍遍的调试和修改中，发现自己的经验在快速增长，这个感觉真的很不错。

然而，实验的运行结果还不是很完美，每个进程在最后一个时间片的运行过程中，进程列表的更新总是修改错误。

不过在在本次试验中学到了不少东西，一点点的在进步。

6、测试结果输入时间片,进程数,进程到达时间,服务时间输出输入时间片,进程数,进程到达时间,服务时间输出7、附录(java)package experiment;import java.io.BufferedInputStream;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.util.Scanner;public class B_RR {// 声明变量// 时间片public static int q = 0;// 允许的最大进程数public static int MaxNum = 100;// 真正的进程数public static int realNum;// order数组的一个下标public static int number;// 当前时间public static int NowTime;// 各进程的达到时间public static int ArrivalTime[] = new int[MaxNum];// 各进程的服务时间public static int ServiceTime[] = new int[MaxNum];// 各进程的服务时间(用于记录进程服务时间随时间片轮转减少的过程)public static int PServiceTime[] = new int[MaxNum];// 各进程的完成时间public static int FinishTime[] = new int[MaxNum];// 各进程的周转时间public static int WholeTime[] = new int[MaxNum];// 进程调度队列（存放的是各个进程的数字代号，如进程A数字代号为1）public static int order[] = new int[MaxNum];// 各进程的带权周转时间public static double WeightWholeTime[] = new double[MaxNum];// 平均周转时间、平均带权周转时间public static double AverageWT, AverageWWT;// 周转时间总和public static int SumWT = 0;// 带权周转时间总和public static double SumWWT = 0;// 进程是否已经结束的标志public static boolean Finished[] = new boolean[MaxNum];public static Scanner stdin;public static void main(String[] args) throws FileNotFoundException {// 从文件中输入数据BufferedInputStream in = new BufferedInputStream(new FileInputStream( "./file/02"));System.setIn(in);stdin = new Scanner(System.in);q = stdin.nextInt(); // 时间片qrealNum = stdin.nextInt(); // 真实进程数for (int i = 0; i < realNum; i++) { // 各进程的服务时间ArrivalTime[i] = stdin.nextInt();}for (int j = 0; j < realNum; j++) { // 各进程的服务时间ServiceTime[j] = stdin.nextInt();PServiceTime[j] = ServiceTime[j]; //用于记录进程服务时间随时间片轮转减少的过程Finished[j] = false;}stdin.close();int all_add = 1; //就绪队列中的进程个数order[0] = 0; //进程调度队列（存放的是各个进程的数字代号，如进程A数字代号为1）number = 1;NowTime = 0; //现在时间while (order[0] != 100) { //order[0]为100，是认为规定进程调度结束的标志// 调度程序char w = 'A';System.out.println("时刻" + NowTime + "：进程" + (char)(w + order[0]) + "开始运行;");if (PServiceTime[order[0]] > q) { //进程还未完成PServiceTime[order[0]] = PServiceTime[order[0]] - q; //对应的进程的服务时间减去一个时间片NowTime += q; //现在时刻增加一个时间片System.out.println("时刻" + NowTime + "：进程" + (char)(w + order[0]) + "停止运行,加入就绪序列尾;");} else { //进程剩一个时间片后结束NowTime += PServiceTime[order[0]]; //现在时间增加一个时间片PServiceTime[order[0]] = 0; //对应进程的服务时间归零System.out.println("时刻" + NowTime + "：进程" + (char)(w + order[0]) + "运行结束;");FinishTime[order[0]] = NowTime;WholeTime[order[0]] = NowTime - ArrivalTime[order[0]];WeightWholeTime[order[0]] = 1.0 * WholeTime[order[0]] / ServiceTime[order[0]];}// 将到达的程序加入序列尾if (all_add < realNum) {for (int i = 1; i < realNum; i++) {if (NowTime >= ArrivalTime[i] && Finished[i] == false) { //判断该进程是否已经在就绪队列中order[number++] = i;all_add++;Finished[i] = true;}}}// 将序列首程序调到序列尾int temp = order[0];for (int i = 0; i < number - 1; i++){ //将order中的每个数前移一位order[i] = order[i + 1];}if (PServiceTime[temp] == 0){ //进程已将全部调度结束，通过将order的第一个数标记为100，来结束进程调度order[--number] = 100;}else{ //进程还未调度结束order[number - 1] = temp;}}double all = 0, all1 = 0;for (int i = 0; i < realNum; i++) {// 计算总周转时间和总带权周转时间all += WholeTime[i];all1 += WeightWholeTime[i];}System.out.println("\n进程名\t到达时间\t服务时间\t完成时间\t周转时间\t 带权周转时间");for (int i = 0; i < realNum; i++) {System.out.println((char)(i + 'A') + "\t" + ArrivalTime[i] + "\t"+ ServiceTime[i] + "\t" + FinishTime[i] + "\t"+ WholeTime[i] + "\t" + WeightWholeTime[i]);}AverageWT = all / realNum;System.out.println("平均周转时间:" + AverageWT);AverageWWT = all1 / realNum;System.out.println("平均带权周转时间: " + AverageWWT);}}。

操作系统实验报告实验名称：时间片轮转调度班级：姓名：学号：实验目的：用高级语言编写和调试一个简单的时间片轮转调度程序，算法要求使用高优先权优先来进行进程调度。

实验内容：（1）用户输入进程名和优先级，并发执行的进程调度程序，每一个进程用一个进程控制块PCB 来代表。

PCB中应包含下列信息：进程名、进程优先数、进程需要运行的时间、占用CPU的时间及进程的状态等，各进程的优先数以及进程运行需要地时间片数，由用户输入。

（2）根据先来先服务原则，执行进程，每执行一次，需要时间减1，CPU时间片加1，在进程运行结束后，会显示进程的周转时间；（3）每个进程处于运行R、就绪W和完成F 三种状态之一，假定初始状态都为就绪状态W。

（4）系统能显示或打印各进程状态和参数的变化情况。

实验步骤：一、输入运行进程数目（测试数据为3）；二、输入选择项（选择时间片轮转调度R）；三、输入进程名称和服务时间；实验结果：小结：在这次试验中，主要掌握的是时间片轮转算法的执行过程，按照先来先服务原则，将进程排成一个队列，进程在所分配的时间片内运行的时候，修改自己的状态位，还有计数器加1操作，所需时间减1操作，时间片用完后，排在进程执行队列的尾部，处理机进行切换。

在进程运行结束后打印周转时间。

在最初实现算法的时候，没有添加计算周转时间的函数，后来通过在修改状态位的循环中添加计数器的累加语句，实现了在进程将状态位修改为“F”的时候系统输出周转时间。

源码：#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[20]; /*进程的名字*/int prio; /*进程的优先级*/int round; /*分配CPU的时间片*/int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; /*进程的状态，W--就绪态，R--执行态，F--完成态*/int count;/*记录执行的次数*/int count2; /*周转时间*/struct node *next; /*链表指针*/}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/int num;void GetFirst(); /*从就绪队列取得第一个节点*/void Output(); /*输出队列信息*/void InsertPrio(PCB *in); /*创建优先级队列，规定优先数越小，优先级越高*/void InsertTime(PCB *in); /*时间片队列*/void InsertFinish(PCB *in); /*时间片队列*/void PrioCreate(); /*优先级输入函数*/void TimeCreate(); /*时间片输入函数*/void Priority(); /*按照优先级调度*/void RoundRun(); /*时间片轮转调度*/int main(void){char chose;printf("请输入要创建的进程数目:\n");scanf("%d",&num);getchar();printf("输入进程的调度方法：(P/R)\n");scanf("%c",&chose);switch(chose){case 'P':case 'p':PrioCreate();Priority();break;case 'R':case 'r':TimeCreate();RoundRun();break;default:break;}Output();return 0;}void GetFirst() /*取得第一个就绪队列节点*/{run = ready;if(ready!=NULL){run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() /*输出队列信息*/{PCB *p;p = ready;printf("进程名\t优先级\t轮数\tcpu时间\t需要时间\t进程状态\t计数器\t周转时间\n"); while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\t%d\n",p->name,p->prio,p->round,p->cputime,p-> needtime,p->state,p->count,p->count2);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\t%d\n",p->name,p->prio,p->round,p->cputime,p-> needtime,p->state,p->count,p->count2);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needt ime,p->state,p->count,p->count2);p = p->next;}}void InsertPrio(PCB *in) /*创建优先级队列，规定优先数越小，优先级越低*/{PCB *fst,*nxt;fst = nxt = ready;if(ready == NULL) /*如果队列为空，则为第一个元素*/{in->next = ready;ready = in;}else /*查到合适的位置进行插入*/{if(in ->prio >= fst ->prio) /*比第一个还要大，则插入到队头*/{in->next = ready;ready = in;}else{while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/{nxt = fst;fst = fst->next;}if(fst ->next == NULL) /*已经搜索到队尾，则其优先级数最小，将其插入到队尾即可*/{in ->next = fst ->next;fst ->next = in;}else /*插入到队列中*/{nxt = in;in ->next = fst;}}}}void InsertTime(PCB *in) /*将进程插入到就绪队列尾部*/{PCB *fst;fst = ready;if(ready == NULL){in->next = ready;ready = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/ {PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void PrioCreate() /*优先级调度输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar(); /*吸收回车符号*/scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/tmp ->round = 0;tmp ->count = 0;tmp ->count2 = 0;InsertPrio(tmp); /*按照优先级从高到低，插入到就绪队列*/}}void TimeCreate() /*时间片输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程时间片所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar();scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 0;tmp ->round = 1; /*假设每个进程所分配的时间片是1*/tmp ->count = 0;tmp ->count2 = 0;InsertTime(tmp);}}void Priority() /*按照优先级调度，每次执行一个时间片*/{int flag = 1;GetFirst();while(run != NULL) /*当就绪队列不为空时，则调度进程如执行队列执行*/{Output(); /*输出每次调度过程中各个节点的状态*/while(flag){int count3;run->prio -= 2; /*优先级减去2*/run->cputime++; /*CPU时间片加一*/run->needtime--;/*进程执行完成的剩余时间减一*/run ->count2++;count3 = run ->count2;if(run->needtime == 0)/*如果进程执行完毕，将进程状态置为F，将其插入到完成队列*/{run ->state = 'F';run->count++; /*进程执行的次数加一*/run ->count2=count3;InsertFinish(run);flag = 0;}else /*将进程状态置为W，入就绪队列*/{run->state = 'W';run->count++; /*进程执行的次数加一*/run->count2++;InsertTime(run);flag = 0;}}flag = 1;GetFirst(); /*继续取就绪队列队头进程进入执行队列*/}}void RoundRun() /*时间片轮转调度算法*/{int flag = 1;GetFirst();while(run != NULL){Output();while(flag){int count3;run->count++;run->cputime++;run->needtime--;run->count2++;count3 = run ->count2;if(run->needtime == 0) /*进程执行完毕*/{run ->state = 'F';run ->count2++;run ->count2=count3;// printf("进程运行结束,shijian %d\n",&count2);InsertFinish(run);flag = 0;}else if(run->count == run->round)/*时间片用完*/{run->state = 'W';run ->count++;run ->count2++;//run->count++;// run->round++;/*计数器清零，为下次做准备*/InsertTime(run);flag = 0;}}flag = 1;GetFirst();}}。

时间片轮转调度算法实现
时间片轮转调度算法（Round Robin Scheduling Algorithm）是一种常用的进程调度算法，其特点是将系统中的所有进程按照一定的时间片大小进行轮流调度执行，从而保证每个进程都能够获得一定的CPU时间，同时避免了某个进程长时间占用CPU的情况。

时间片轮转调度算法的基本原理是将所有就绪进程按照先后顺序排成一个队列，然后按照固定的时间片大小为每个进程分配一定的CPU时间，并在时间片用完后将进程从队列头部移到队列尾部，等待下一次调度。

这样，每个进程都能够得到一定的CPU时间，同时也保证了系统的公平性和响应性。

在实际运用中，时间片大小的选择对于系统的性能和响应速度有着重要的影响。

如果时间片过短，会导致进程过于频繁地进行上下文切换，从而降低系统的效率；如果时间片过长，会导致某些进程长时间占用CPU资源，影响其他进程的运行。

因此，在进行时间片大小的选择时，需要考虑系统的硬件配置、进程的性质、调度算法的实现等多方面因素。

通常情况下，时间片大小的选择应该根据实际情况进行调整，以保证系统的性能和响应速度。

除了时间片大小的选择之外，时间片轮转调度算法还有其它一些优化技巧，例如优先级调度、多级反馈队列调度等。

这些技巧能够进
一步提高系统的性能和响应速度，同时也能够更好地适应不同性质的进程。

时间片轮转调度算法是一种简单而有效的进程调度算法，在实际运用中有着广泛的应用。

通过合理地选择时间片大小、实现优化技巧等手段，能够更好地提高系统的性能和响应速度，为用户提供更加优质的服务。

时间片轮转调度算法时间片轮转调度算法是一种用于处理多道程序的调度算法，它按照时间片的大小将CPU的使用权交给不同的进程。

这种算法的基本思想是每个进程被分配一个时间段，称为时间片。

当时间片用完时，操作系统会将当前进程挂起，然后将CPU的控制权交给下一个进程。

时间片轮转调度算法可以确保所有的进程都有机会执行，并且不会让一些进程独占CPU资源。

时间片轮转调度算法的实现非常简单。

在这种算法中，操作系统维护一个就绪队列，其中存放了所有等待执行的进程。

操作系统按照队列中进程的先后顺序分配CPU的使用权，每个进程被分配一个固定大小的时间片。

当一个进程的时间片用完时，操作系统将其放入就绪队列的末尾，并将CPU的使用权交给下一个进程。

除了公平性，时间片轮转调度算法还具有响应快的特点。

由于每个进程都只能执行一个固定大小的时间段，因此当一个进程被挂起时，操作系统会立即将CPU的控制权转移到下一个进程，从而减少了响应时间。

然而，时间片轮转调度算法也存在一些缺点。

首先，如果时间片设置得太小，会导致进程切换频繁，从而增加了操作系统的开销。

而如果时间片设置得太大，又可能出现一些进程运行时间过长的情况，造成其他进程长时间等待。

另外，时间片轮转调度算法对于长时间运行的进程来说，可能不够高效。

如果一个进程需要执行的时间超过了时间片的大小，那么它会被挂起并放入就绪队列的末尾，然后进程切换到下一个进程执行。

然而，当这个进程再次被调度时，它需要重新加载状态等信息，这将导致一些额外的开销。

为了解决这个问题，可以使用动态调整时间片大小的方法。

例如，可以根据进程的优先级来调整时间片的大小，优先级较高的进程可以分配更长的时间片，从而提高其执行效率。

同时，为了进一步提高系统的性能，还可以使用多级反馈队列调度算法，根据进程的历史行为调整时间片的大小。

总的来说，时间片轮转调度算法是一种简单且公平的调度算法，适用于多道程序环境下的进程调度。

它的实现简单，但需要合理地设置时间片的大小，以平衡系统的响应时间和效率。

操作系统实验报告第一次实验——时间片调度轮转算法实验时间：2014.11.7院系：计算机科学与技术学院班级：软件2班实验要求：（1）实验选题：时间片调度轮转算法（2）程序流程图及程序代码程序代码:#include<stdio.h>#include<conio.h>#define N 20typedef struct pcb{char pname[N];int runtime;int arrivetime;char state;struct pcb*next;}PCB;PCB head_input;PCB head_run;PCB * pcb_input;static char R='r',C='c'; unsigned long current;void inputprocess();int readyprocess();int readydata();int runprocess();FILE *f;int readyprocess(){while(1){if(readydata()==0)return 1;elserunprocess();}}int readydata(){if(head_input.next==NULL){if(head_run.next==NULL)return 0;elsereturn 1;}PCB *p1,*p2,*p3;p1=head_run.next;p2=&head_run;while(p1!=NULL){p2=p1;p1=p2->next;}p1=p2;p3=head_input.next;p2=&head_input;while(p3!=NULL){if(((unsigned long)p3->arrivetime<=current)&&(p3->state==R)){printf("时间片为%8d(时间%4d);进程%s 开始,\n",current,(current+500)/1000,p3->pname);fprintf(f,"时间片为%8d(时间%4d);进程%s 开始,\n",current,(current+500)/1000,p3->pname);p2->next=p3->next;p3->next=p1->next;p1->next=p3;p3=p2;}p3=p3;p3=p3->next;}return 1;}int runprocess(){PCB *p1,*p2;if(head_run.next==NULL){current++;return 1;}else{p1=head_run.next;p2=&head_run;while(p1!=NULL){p1->runtime--;current++;if(p1->runtime<=0){printf("时间片为%8d 时间%4d 进程%s 结束.\n",current,(current+500)/1000,p1->pname);fprintf(f,"时间片为%8d 时间%4d 进程%s 结束.\n",current,(current+500)/1000,p1->pname);p1->state=C;p2->next=p1->next;delete p1;p1=NULL;}else{p2=p1;p1=p2->next;}}return 1;}}void inputprocess(){PCB *p1,*p2;int num;unsigned long max=0;printf("请输入进程的数量:");fprintf(f,"请输入进程的数量:");scanf("%d",&num);fprintf(f,"%d\n",&num);p1=&head_input;p2=p1;p1->next=new PCB;p1=p1->next;for(int i=0;i<num;i++){printf("请输入第%d个进程的进程名:",i+1);fprintf(f,"请输入第%d个进程的进程名:",i+1);scanf("%s",p1->pname);fprintf(f,"%s\n",p1->pname);printf("它的运行时间为:");fprintf(f,"它的运行时间为:");scanf("%d",&(p1->runtime));fprintf(f,"%d\n",&(p1->runtime));printf("它的到达时间为:");fprintf(f,"它的到达时间为:");scanf("%d",&(p1->arrivetime));fprintf(f,"%d\n",&(p1->arrivetime));p1->runtime=(p1->runtime)*1000;p1->arrivetime=(p1->arrivetime)*1000;p1->state=R;if((unsigned long)(p1->arrivetime)>max)max=p1->arrivetime;p1->next=new PCB;p2=p1;p1=p1->next;}delete p1;p1=NULL;p2->next=NULL;}void main(){f=fopen("result.txt","w");printf("时间1=1000 时间片\n");fprintf(f,"\ntime 1=1000 time slice\n");current=0;inputprocess();readyprocess();getch();fclose(f);}（3）PCB数据结构typedef struct pcb{char pname[N];int runtime;int arrivetime;char state;struct pcb*next;}PCB;（4）程序运行结果（5）总结掌握了时间片轮转调度算法，时间片的大小确定很重要。

时间片轮转调度算法java可视化模拟程序如何实现一个时间片轮转调度算法的java可视化模拟程序？时间片轮转调度算法是操作系统中常用的一种调度算法，它可以确保所有进程公平并且均衡地使用CPU资源。

在时间片轮转调度算法中，每个进程被分配一个固定的时间片，在这个时间片内执行，如果时间片用完，进程将被挂起，并将CPU资源分配给下一个进程。

为了更好地理解和学习时间片轮转调度算法，我们可以通过编写一个简单的java可视化模拟程序来模拟这个过程。

下面将一步一步回答如何实现这个模拟程序。

第一步：创建一个进程类我们需要创建一个Process类来表示每个进程。

这个类应该包含以下属性：- 进程ID（唯一标识符）- 进程名称- 进程到达时间- 进程需要的总执行时间- 进程已经执行的时间同时，这个类还应该包含一些方法来获取和修改这些属性的值。

第二步：创建一个调度类我们需要创建一个Scheduler类来模拟时间片轮转调度算法。

这个类应该包含以下属性：- 调度队列（用来存放进程的队列）- 时间片大小- 当前执行的进程同时，这个类还应该包含一些方法来模拟时间片轮转调度算法的执行过程，例如：- 将进程添加到调度队列- 根据时间片大小执行当前进程- 将当前进程挂起并将CPU资源分配给下一个进程第三步：编写可视化界面我们需要创建一个可视化界面来显示进程的执行和调度过程。

我们可以使用Java的图形界面库（如Swing或JavaFX）来实现这个界面。

界面应该包含以下组件：- 一个文本框用来输入进程的信息（进程ID，到达时间，执行时间等）- 一个按钮用来添加进程到调度队列- 一个文本框用来显示当前正在执行的进程信息- 一个文本框用来显示调度队列中的进程信息- 一个文本框用来显示每个进程的执行情况（已经执行的时间，还需要执行的时间等）- 一个按钮用来开始模拟时间片轮转调度算法的执行过程第四步：实现模拟程序的逻辑在可视化界面中，当用户点击“添加进程”按钮时，应该将进程添加到调度队列中。

郑州轻工业学院实验报告课程名称：操作系统姓名：学号：专业班级：任课教师：黄伟2016 年11 月 2 日实验报告成绩评定表实验报告正文实验二时间片轮转调度算法设计与实现一、实验目的目的：了解并掌握时间片轮转调度算法的理论，熟悉并掌握时间片设置的大小对系统的影响。

任务：模拟实现时间片轮转调度算法。

二、实验内容1．任务描述1）时间片轮转调度算法问题简介时间片轮转的主要思想就是按顺序为每一个进程一次只分配一个时间片的时间。

算法要完成的功能就是将各个进程按照时间片轮转运行的动态过程显示出来。

时间片轮转算法的主要实现过程是首先为每一个进程创建一个进程控制块，定义数据结构，说明进程控制块所包含的内容，有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息。

实现的过程即运用指针指向某一个进程，判断当前的进程是否是就绪状态“r”，如果是，则为该进程分配一个时间片，同时，已运行时间加一且要求运行的时间减一，如此循环执行，当某一个进程的所需要运行的时间减少至0时，则将该进程的状态设置为“e”。

然后，将指针指向下一个未运行完成的进程，重复判断，直至所有的进程都运行结束。

2）设计任务简介模拟实现时间片轮转调度算法，具体如下：设置进程体：进程名，进程的到达时间，服务时间，，进程状态（W——等待,R——运行,F——完成），进程间的链接指针进程初始化：由用户输入进程名、服务时间进行初始化，同时，初始化进程的状态为W。

显示函数：在进程调度前、调度中和调度后进行显示。

排序函数：对就绪状态的进程按照进入就绪队列的时间排序，新到达的进行应优先于刚刚执行过的进程进入就绪队列的队尾。

注意考虑到达时间调度函数：每次从就绪队列队首调度优一个进程执行，状态变化。

并在执行一个时间片后化，服务时间变化，状态变化。

当服务时间为0时，状态变为F。

删除函数：撤销状态为F的进行。

2．调度问题的表示方案首先每一个进程用一个进程控制块PCB来代表。

操作系统时间片轮转算法时间片轮转算法（Round-Robin Scheduling Algorithm）是一种常见的调度算法，用于多道程序设计中进程的分时调度。

该算法将所有就绪状态的进程按照一定顺序排列成一个队列，每个进程被分配一个时间片（时间片长度可以设定），在该时间片结束后，进程被暂停，然后被放回队列的末尾，让其他进程获得CPU执行权限。

时间片轮转算法的主要目的是为了实现公平地分配CPU时间。

时间片轮转算法的实现逻辑如下：1.将就绪态的进程按照到达时间的先后顺序排列成一个就绪队列。

2.初始化一个计时器，设定时间片的长度。

3.从就绪队列中选择第一个进程，将其设为运行状态，并开始计时。

4.当计时器到达时间片长度时，将当前正在运行的进程置为就绪状态，放回就绪队列的末尾。

5.从就绪队列中选择下一个进程，将其设为运行状态，并开始计时。

6.重复步骤4和步骤5，直到所有进程都执行完成。

时间片轮转算法的优点是实现简单、公平性好，但也有一些缺点：1.时间片的设置需要合理，过小可能导致进程切换频繁，降低了系统的吞吐量；过大可能导致响应时间过长，影响用户的体验。

2.如果一些进程的执行时间超过一个时间片的长度，该进程将会不断重新被放回队列尾部，导致该进程无法快速执行完成。

3.在高负载情况下，由于进程的切换开销较大，时间片轮转算法可能导致性能下降。

为了解决时间片轮转算法的一些缺点1.动态调整时间片长度：根据系统当前的负载情况，动态调整时间片的长度。

当系统负载较轻时，可以适当增加时间片的长度，以提高系统吞吐量；当系统负载较重时，可以适当减小时间片的长度，以提高响应速度。

2.抢占式调度：在时间片轮转算法的基础上，引入优先级的概念，当高优先级进程抵达时，可以抢占当前正在执行的低优先级进程，从而提高高优先级进程的执行速度。

3.多级反馈队列调度：将就绪队列按照优先级划分成多个队列，每个队列拥有不同的时间片长度。

当一个进程在一些队列中执行的时间超过了该队列的时间片长度时，将其移到下一个优先级队列中继续执行。

目录一、设计目的 (1)二、设计内容 (2)三、设计原理 (2)四、算法实现 (4)五、流程图 (6)六、源程序 (7)七、运行示例及结果分析 (12)八、心得体会 (12)九、参考资料 (13)时间片轮转法进行CPU调度一、设计目的处理机调度是操作系统中非常重要的部分。

为深入理解进程管理部分的功能，设计调度算法，模拟实现处理机的调度。

本课程设计是用时间片轮转算法模拟单处理机调度。

（1）创建进程，每个进程包括三组数据：进程名，进程到达时间，服务时间。

（2）自定义模拟的进程数目。

在进程数目之内，手动输入进程（进程名、到达时间和服务时间）。

自定义时间片大小。

（3）定义一个时间轴，为参考。

（4）初始化时间轴，根据先到先服务的原则，将已到达的进程插入到执行队列。

（5）分配给执行队列的队首一个时间片，开始运行时间片减1，时间轴则向前推进1,。

时间轴每推进一秒，检索是否有新的进程到达，若有则将到达的进程插入到执行队列的队尾。

（6）进程每运行1秒，服务时间减1，同时判断该进程是否运行完（服务时间是否为零）。

运行完则退出执行队列。

若没有则等待下一次运行。

（7）当一个时间片用完时，判断所有进程是否都运行完，若有，该模拟实验结束。

（8）当一个时间片用完时，判断该队首是否运行过一个完整的时间片，没有则保持该执行队列顺序不变。

有，则将该进程插入到队尾。

分配新的时间片给队首。

系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。

时间片的大小从几ms到几百ms。

当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾：然后，再把处理机分配给就绪队列中的队首进程，同时也让它执行一个时间片。

这样就可以保证就绪队列中的所有进程在一给定的时间内获得一时间片的处理机执行时间。

换言之，系统能在给定的时间内响应所有用户的请求。

操作系统实验报告时间片轮转调度算法“网络协议分析”实验4实验名称：用Ethereal研究DNS和HTTP协议实验目的：通过对捕获分组的分析和研究，加深对DNS协议和HTTP协议的工作原理和实现过程的理解。

实验环境：连网PC机，Ethereal网络协议分析软件实验步骤：1．安装Ethereal网络协议分析器。

2．打开Ethereal软件菜单中的Help->Contents，可学习Ethereal的使用方法。

3．开始捕获分组之前，清空客户端Web浏览器的高速缓存和DNS的高速缓存（命令为：ipconfig /flushdns）。

（想一想，为什么？）4．在Capture->Option里选择网卡类型；取消捕获分组的“混杂模式”；设置捕获过滤器为：“host 本机IP”，这样Ethereal就会只捕获从本机发出的和发往本机的分组。

5．点击Start启动协议分析器，用Ethereal捕获从本机发出和发往本机的分组。

6．在Web浏览器中输入URL（如.cn, 等，网页较简单）。

网页显示出来后，过一会儿停止捕获。

将跟踪文件保存在一个文件中。

实验结果分析：1．在跟踪列表框中找出请求网页时发出的DNS查询报文和回答报文，找出发起TCP连接的三次握手报文，找出HTTP请求报文和响应报文。

2．在协议框中找出各层协议，观察各层协议，并对照教材中DNS查询/回答报文结构和HTTP请求/响应报文结构对这些应用层报文进行分析，找出报文中各字段相应的内容，解释其含义和用途。

3．你的主机所用的DNS服务器的IP地址是多少？你的浏览器与DNS服务器之间使用传输层的什么协议进行通信？202.196.0.1DNS请求报文和应答报文的ID号一样吗？是什么？一样，0xc4a6你所请求网站的规范名是什么？mail.DNS服务器对你的域名解析请求在应答中给出了几个可用的IP地址？都是什么？2个，202.196.0.16，202.196.0.17和DNS服务器通信时，你的客户机使用的端口号是多少？DNS服务器使用的端口号是多少？64384，53你所请求Web服务器的IP地址是什么？其域名有几个层次（参看教材127页）？202.196.0.16 4个如果请求一个存在/不存在的网页，Web服务器分别会应答什么？ ??等等。

RR时间⽚轮转算法（java）操作系统中的时间⽚算法运⾏结果流程图---------------------java代码------------------------package operate;import java.util.LinkedList;import java.util.PriorityQueue;import java.util.Queue;import java.util.Scanner;/*** 时间⽚轮转调度算法* 抢占式，单CPU* @author ymj* @Date： 2019/12/15 23:13*/public class RR {static Scanner cin = new Scanner(System.in);/** 进程控制块 */static class PCB implements Comparable<PCB>{int id; // 进程idint arriveTime; // 到达时间int runTime; // 运⾏时间int hasRanTime = 0; // 已经运⾏时间，初始值为0int turnAroundTime; // 周转时间int waitTime; // 等待时间int responseTime;// 响应时间 == ⾸次运⾏时间-到达时间PCB(int id, int arriveTime, int runTime){this.id = id;this.arriveTime = arriveTime;this.runTime = runTime;}@Overridepublic int compareTo(PCB o) { // 按照到达时间进⼊就绪队列return this.arriveTime - o.arriveTime;}}static PCB[] pcbs; // 进程数组static int timeSlice; // 时间⽚/** 进程到达队列 */static Queue<PCB> queue = new PriorityQueue<>();/** 初始化 PCB 信息 */static void initPCB(){System.out.print("输⼊进程数： ");int num = cin.nextInt();pcbs = new PCB[num+1];System.out.println("输⼊到达时间，运⾏时间");for(int i = 1; i <= num; i++) {System.out.print("进程" + i + ":");pcbs[i] = new PCB(i, cin.nextInt(), cin.nextInt());queue.offer(pcbs[i]);}System.out.print("输⼊时间⽚⼤⼩：");timeSlice = cin.nextInt();}/** 判断当前已经到达的进程，并使之进⼊就绪队列 */static boolean judge(Queue<PCB> readyQueue, int currentTime){boolean flag = false; // 为 true 表⽰有到达的进程while (true){PCB pcb = queue.peek(); // 最先到达的进程if (pcb == null){ // 所有进程都已经进⼊了就绪队列break;}else if(pcb.arriveTime <= currentTime){ // 当前有进程到达PCB runPCB = queue.poll();readyQueue.offer(runPCB); // 进⼊就绪队列等待运⾏flag = true;}else { // 当前没有进程到达break;}}return flag;}/** 进程进⼊处理机运⾏, 如果进程运⾏完成返回 true*/static boolean processRun(PCB pcb, int currentTime){if(pcb.hasRanTime == 0){ // 进程⾸次运⾏时间pcb.responseTime = currentTime;}pcb.hasRanTime++; // 进⼊处理机运⾏System.out.printf(" %d\n", pcb.id);if(pcb.hasRanTime == pcb.runTime){ // 进程已经结束pcb.turnAroundTime = currentTime+1 - pcb.arriveTime; // 周转时间pcb.waitTime = pcb.turnAroundTime - pcb.runTime; // 等待时间pcb.responseTime -= pcb.arriveTime;return true;}else {return false;}}/** 处理机运⾏ */static void run() {int currentTime = 0; // 当前时间if(!queue.isEmpty()){currentTime = queue.peek().arriveTime;}/** 定义就绪队列 */Queue<PCB> readyQueue = new LinkedList<>();int timeSliceFlag = timeSlice; // 时间⽚标记（假设刚开始是⼀个时间⽚的开始）PCB runPcb = null;System.out.println("now 正在运⾏的进程");while (true) {System.out.printf("%d\t ", currentTime);if(queue.isEmpty() && readyQueue.isEmpty() && runPcb== null){System.out.println("当前所有进程运⾏结束");break;}else{ // 进程进⼊处理机运⾏/** 判断是否到⼀个时间⽚ */if(timeSliceFlag % timeSlice == 0){ // ⼀个时间⽚到/** 判断当前已经到达的进程，并使之进⼊就绪队列 */judge(readyQueue, currentTime);if(runPcb != null){ // 处理机上还有进程// 此时要下处理机，进⼊就绪队列readyQueue.offer(runPcb);runPcb = null; // 此时处理机空闲}runPcb = readyQueue.poll(); // 出就绪队列，if(runPcb == null){ // 就绪队列为空, 意味着此时处理机空闲，⽽且没有到达的进程 currentTime++; // 处理机等待System.out.printf(" 处理机空闲,\n");continue; // 进⼊下⼀轮}}/** 在处理机中运⾏进程-->runPCB*/if(processRun(runPcb, currentTime) == true){ // 运⾏后进程已经结束runPcb = null;timeSliceFlag = timeSlice; // 重新开始⼀个新的时间⽚}else { // 进程没有结束timeSliceFlag++;}/** 时间⽚+1 */currentTime++;}}}public static void main(String[] args) {initPCB();System.out.println("-----处理机开始运⾏-----");run();System.out.println("-----处理机运⾏结束-----");showTurnAroundTime();}// 周转时间private static void showTurnAroundTime() {double averageT = 0;double averageWTAT = 0;double averageWT = 0;System.out.println("进程\t 周转时间\t 带权周转时间\t 等待时间\t 响应时间\t");for (int i = 1; i < pcbs.length; i ++) {int turnAroundTime = pcbs[i].turnAroundTime;double weightTurnAroundTime = turnAroundTime*1.0/pcbs[i].runTime;int waitTime = pcbs[i].waitTime;int responseTime = pcbs[i].responseTime;System.out.printf("%d\t %d\t\t\t %.2f\t\t\t %d\t\t\t %d\n" ,i , turnAroundTime, weightTurnAroundTime, waitTime, responseTime); averageT += turnAroundTime;averageWTAT += weightTurnAroundTime;averageWT += waitTime;}averageT /= pcbs.length-1;averageWTAT /= pcbs.length-1;averageWT /= pcbs.length-1;System.out.println("平均周转时间：" + averageT);System.out.printf("平均带权周转时间：%.2f\n", averageWTAT);System.out.println("平均等待时间：" + averageWT);}}。

Java实现进程调度算法（⼆）RR（时间⽚轮转）⼀、概述 因为这次os作业对⽤户在控制台的输⼊输出有要求，所以我花了挺多的代码来完善控制台的显⽰。

也因为我这次要实现多个类似算法，所以将⼀些共性单独提取出来作为⼀个类。

如果只想要和算法有关的核⼼代码，看RR类的calc()即可。

实现思路：每运⾏⼀个进程，则将所有进程的remainServiceTime减去⼀个时间⽚的长度。

⼆、运⾏结果 1. 测试数据： 2. 运⾏结果：三、流程图四、实现代码 1. RR类（主类）只有calc()中涉及了算法，init()和printResult()只有简单的输⼊输出操作。

1package xqy.algorithm;23import java.util.*;45import xqy.Util.Tools;6import xqy.been.Process;78/**9 * @author xqy10 * @date 2018年12⽉19⽇19:14:4911*/12public class RR {13private int processNumber;14private ArrayList<Process> processList;15private int timeSlice;1617public RR() {18 init();19 calc();20 Tools.printResult(processList);21 }2223private void init() {24 Scanner sc = new Scanner(System.in);2526 System.out.print("<RR> Please enter the slice time:");27 timeSlice = sc.nextInt();28 System.out.print("<RR> please enter the process num:");29 processNumber = sc.nextInt();3031 processList = new ArrayList<Process>();32for (int i = 0; i < processNumber; i++) {33 processList.add(new Process());34 }3536 System.out.println("<RR> Please enter each process arrival time:");37for (int i = 0; i < processNumber; i++) {38 System.out.print(" Process" + (i + 1) + ":");39 processList.get(i).setArrivalTime(sc.nextInt());40 }4142 System.out.println("<RR> Please enter each process service time:");43for (int i = 0; i < processNumber; i++) {44 System.out.print(" Process" + (i + 1) + ":");45int servicesTime = sc.nextInt();4647 processList.get(i).setServicesTime(servicesTime);48 processList.get(i).setRemainServiceTime(servicesTime);49 }50 }5152private void calc() {53int timeNow = 0;54int processRemain = processNumber;55boolean noProcessRunInThisTurn;56 Process opProcess;5758while (processRemain != 0) {59 noProcessRunInThisTurn = true;6061for (int i = 0; i < processNumber; i++) {62 opProcess = processList.get(i);6364if ((opProcess.getRemainServiceTime() > 0)65 && (timeNow >= opProcess.getArrivalTime())) {66// First time67if (opProcess.getServicesTime() == opProcess68 .getRemainServiceTime()) {69int waitTime = timeNow - opProcess.getArrivalTime();7071 opProcess.setStartTime(timeNow);72 opProcess.setWaitTime(waitTime);73 }7475// Calculating remain service time76int remainServiceTime = opProcess.getRemainServiceTime()77 - timeSlice;78 opProcess.setRemainServiceTime(remainServiceTime);7980// Last time81if (remainServiceTime <= 0) {82int completionTime = timeNow + timeSlice; // The process ends when the current slice is completed. 83int turnAroundTime = completionTime84 - opProcess.getArrivalTime();85double turnAroundTimeWithWeight = 1.0 * turnAroundTime86 / opProcess.getServicesTime();8788 opProcess.setCompletionTime(completionTime);89 opProcess.setTurnAroundTime(turnAroundTime);90 opProcess91 .setTurnAroundTimeWithWeight(turnAroundTimeWithWeight);92 processRemain--;93 }9495 timeNow += timeSlice;96 noProcessRunInThisTurn = false;9798 System.out.println(" #STEP# Process" + (i + 1)99 + " remain service time:"100 + opProcess.getRemainServiceTime()101 + " , timeBefore:" + (timeNow - 1) + ", timeNow:"102 + timeNow103 + ((remainServiceTime <= 0) ? " Finish" : ""));104 } else {105// do noting, because this process has been completed or hasn`t arrived.106 }107 }108109// Means no process could run, because they have arrived.110if ((processRemain > 0) && noProcessRunInThisTurn) {111 timeNow += timeSlice;112 }113 }114 }115 } 2. Process类模拟了进程，对属性进⾏了封装。

操作系统之时间片轮转法实现代码#include <iostream>using namespace std;struct zuoye{char name;float time;};int main(){float cputime;int zuoyenum;float temp;cout<<"请输入cpu的时间片：";cin>>cputime;cout<<"请输入作业数：";cin>>zuoyenum;struct zuoye a[zuoyenum];cout<<"请输入每个作业的作业名和需处理的时间："<<endl;for(int i=1;i<=zuoyenum;i++){cout<<"请输入第"<<i<<"个作业的时间和需处理的时间："<<endl;cin>>a[i].name>>a[i].time;}temp=a[1].time;for(int i=1;i<=zuoyenum;i++){if(a[i].time>temp)temp=a[i].time;}int j=1;int k=1;for(int i=0;i<temp/cputime;i++){for(int j=1;j<=zuoyenum;j++){if(a[j].time>0){a[j].time=a[j].time-cputime;if(a[j].time<0)a[j].time=0;cout<<a[j].name<<"-->"<<a[j].time<<"; ";}if(j==zuoyenum)cout<<endl;}}return 1;}。

成一个循环链队列，用函数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)，每次选中进程的进程名以及运行一次后进程队列的变化，实现处理器的调度。

调试分析：5. 程序的运行及结果5.1错误调试开始运行到Q5运行完成后显示错误，如下图所示：图4：错误调试原因：经检查程序发现语句if(s->condition=='e' ){printf("进程%s已经运行完成！\n\n",s->name);}有错误，因为当某个进程运行完成后，其状态标志已修改为’e’，所以再次循环运行未完成的进程时，当运行到此句时仍会将前面已完成的进程重新输出一遍完成信息，导致输出错误。

解决方案：为每个进程加上一个结束标志flag，并赋初值为0，当进程运行完成后，将flag改为1，再将后面输出改为if(s->condition=='e' || s->flag==0 ){printf("进程%s已经运行完成！\n\n",s->name);s->flag==0;}，这样在前面进程运行完成输出后，后面再循环时就不会重新输出一遍了。

时间片轮转调度算法资料《操作系统》课程实验报告实验名称：时间片轮转调度算法班级：****************学号：*************姓名：**************指导老师：***************成绩：一、实验目的：1、测试数据可以随即输入或从文件中读入。

2、必须要考虑到进程的到达时间3、最终能够计算每一个进程的周转时间的带权周转时间。

4、时间片大小可以不为1，但至少实现时间片大小为1的RR调度。

二、实验内容：模拟实现时间片轮转调度算法，具体如下：设置进程体：进程名，进程的到达时间，服务时间，，进程状态（W——等待,R ——运行,F——完成），进程间的链接指针进程初始化：由用户输入进程名、服务时间进行初始化，同时，初始化进程的状态为W。

显示函数：在进程调度前、调度中和调度后进行显示。

排序函数：对就绪状态的进程按照进入就绪队列的时间排序，新到达的进行应优先于刚刚执行过的进程进入就绪队列的队尾。

调度函数：每次从就绪队列队首调度优一个进程执行，状态变化。

并在执行一个时间片后化，服务时间变化，状态变化。

当服务时间为0时，状态变为F。

删除函数：撤销状态为F的进行。

三、实验代码#include#include#includetypedefstruct PCB2{char name[10];//进程名int runtime;//要求运行时间intfrist;//定义优先数char zhuangtai; //定义状态，R为就绪，F为完成};structshijian {//定义时间片的结构体char name; //定义进程名intdaodatime;// 到达时间intfuwutime; //服务时间intshengyutime;//剩余时间char *state;//所处状态structshijian *next;};structshijian *time(){inta,i;structshijian *head, *rear,*p,*q,*t;//定义队首、队尾、P是队尾指针、Q是队首指针和执行时间head=rear=NULL;//初始化队首和队尾为空printf("请输入进程数目：");scanf("%d",&a);for(i=0;i<a;i++)< p="">{p=(structshijian*)malloc(sizeof(structshijian)); //初始化一个空间给进程进入printf("输入第%d个进程的名字、到达时间、服务时间:\n",i+1);scanf("%s%d%d",&p->name,&p->daodatime,&p->fuwutim e);p->shengyutime=p->fuwutime;p->state="就绪";if(rear==NULL) //当输入结束时，把P的数据放到队首，以便执行下一步{head=p;p->next=NULL;rear=p;}else //否则执行时间就为空，队首变成Q{t=NULL;q=head;while(q&&q->daodatimedaodatime)//当Q和Q的到达时间小于P 的到达时间时，把执行时间给Q{t=q;q=q->next;}if(q==head) //而当Q是队首时，则下一个队首变成P，以便每个进程都能够得到时间片{p->next=head;head=p;}else if(t==rear) //当执行时间片到达队尾时（执行完时），返回给队首P{rear->next=p;p->next=NULL;rear=p;}else //否则给队首P占用执行时间，P执行完后到Q{t->next=p;p->next=q;}}}return head;//返回队首}void output(structshijian *head)//定义输出函数{structshijian *p,*t,*r;intnum;printf("请输入时间片:");scanf("%d",&num);while(head!=NULL) //当队首不为空时，把P给队首{r=p=head;while(p!=NULL) //把执行时间给队首{t=head;p->shengyutime=p->shengyutime-num; //P的剩余时间=剩余时间-时间片p->state="运行"; //状态变成运行态if(p->shengyutime<0) //当P运行完，即剩余时间小于0时，仍然把它当做0处理p->shengyutime=0;printf("\n************程序开始运行*****************\n");printf("进程到达时间服务时间剩余时间当前状态\n");while(t!=NULL) //时间不为空时，输出当前进程的信息，并把时间片交给下一个进程{printf("%2c%8d%8d%14d%10s\n",t->name,t->daodatime,t->fuwutime,t->shengy utime,t->state);t=t->next;}getchar(); //按住回车键观看if(p->shengyutime==0)//当队首的剩余时间为0时，先把队首改成P 的下一个，然后释放内存，删除队首节点{if(p==head){head=p->next;free(p);p=head;}else //否则返回执行，把队尾的下一个指针变成P的下一个指针，队尾的位置移动到队首{r->next=p->next;p=r->next;r=p;}}else //否则把队首的位置给队尾，把队首的状态显示为“就绪”状态r=p;p->state="就绪";p=p->next;}}}}void main(){int N;int number;char Tishikuang;//提示框do{printf("★*********★********★*******★******★********★*********★******** ****★\n");printf("*************嵌入式软件14-01班****51********杨霖***************************\n");printf(" ** 输入1—时间片轮转法**\n");printf(" ** 输入0—退出该程序**\n");printf("*************************************************************** ****** **\n");printf("\n注:请根据自己的需求选择相应的操作数：\n");scanf("%d",&number);/*提示输入字母，用switch语句存入到case中，最后增加提示框是否继续*/switch(number)case 0:break;case 1:printf("\n您选择的是“时间片轮转法项目”\n\n"); structshijian *head; //定义时间片的队首结构体head=time(); //队首执行的时间output(head) ;//输出函数break;}printf("\n是否继续操作(y/n) ?");fflush(stdin);Tishikuang=getchar();}while(Tishikuang=='y'||Tishikuang=='Y');}四、实验结果五、实验总结1.时间片轮转可以使用时间片的长度来控制进程，若采用时间片为1则会出现每次执行一个时间单位长度然后按照先到先执行的原则；2时间片的长度不宜过长，过长的话没有意义，过短的话就会造成资源浪费；</a;i++)<>。

时间片轮转调度算法是操作系统中常用的调度算法之一，它能够有效地分配CPU时间片给各个进程，从而实现公平地对待所有进程，并降低响应时间。

1. 时间片轮转调度算法的基本原理时间片轮转调度算法是一种基于时间片的轮询调度算法。

它将每个进程分配一个小的时间片，当一个进程的时间片用完了，操作系统将其移到就绪队列的末尾，并将CPU分配给下一个进程。

这样，所有进程都能获得公平的CPU时间，而且在短时间内能够得到响应。

2. 时间片轮转调度算法的实现在Java中，我们可以通过使用队列来实现时间片轮转调度算法。

我们需要定义一个进程类，该类包含进程的ID、CPU时间和已经执行的时间等属性。

我们创建一个就绪队列，将所有进程按照它们到达的顺序加入队列中。

我们使用一个循环来模拟时间片的轮转，当一个进程的时间片用完后，将其移到队列的末尾，并将CPU分配给队列中的下一个进程。

3. 时间片轮转调度算法的优缺点时间片轮转调度算法的优点是能够公平地分配CPU时间，每个进程都能够在短时间内得到响应。

而且，它能够减少进程的等待时间，提高系统的响应速度。

但是，时间片轮转调度算法也存在着一些缺点，比如对于I/O密集型的进程来说，由于频繁地切换进程，可能会导致额外的开销。

4. 个人观点和理解时间片轮转调度算法是一种简单有效的调度算法，特别适用于多用户、交互式的系统。

在实际的应用中，我们可以根据系统的特点和需求来选择合适的调度算法，以达到更好的性能和用户体验。

总结回顾：时间片轮转调度算法是一种重要的调度算法，它能够有效地分配CPU时间，并提高系统的响应速度。

在Java中，我们可以通过使用队列来实现时间片轮转调度算法。

虽然它有一些缺点，但是在多用户、交互式的系统中仍然具有重要的应用意义。

选择合适的调度算法对系统的性能和用户体验都非常重要。

时间片轮转调度算法是一种在操作系统中常用的调度算法，它能够有效地分配CPU时间片给各个进程，从而实现对所有进程的公平处理，并降低系统的响应时间。

时间⽚轮转算法实现⼀、实验内容编程实现时间⽚轮转算法，并求出每个作业的完成时间、周转时间、带权周转时间，及平均周转时间、平均带权周转时间。

⼆、实验要求任选⼀种⾼级语⾔实现；选择1-2种调度算法；能够输⼊进程的基本信息，如进程名、提交时间、预估运⾏时间等；根据选择的调度算法显⽰进程调度顺序；显⽰完成调度后每个进程的开始时间、完成时间呢、周转时间，带权周转时间；计算平均周转时间和平均带权周转时间；三、实验过程1、设计思想系统将所有的就绪进程按FCFS策略排成⼀个就绪队列。

系统可设置每隔⼀定时间(如30ms)便产⽣⼀次中断，去激活进程调度程序进⾏调度，把CPU分配给队⾸进程，并令其执⾏⼀个时间⽚。

当它运⾏完毕后，将进程管道就绪队列的队尾，再把处理机分配给就绪队列中新的队⾸进程，也让它执⾏⼀个时间⽚，以此类推。

这样，就可以保证就绪队列中的所有进程在确定的时间段内，都能获得⼀个时间⽚的处理机时间。

将进程按FCFS排成⼀个队列，每次调度取队⾸进程分配CPU，时间⽚到，将PCB挂到就绪队尾。

在时间⽚轮转调度算法中，应在何时进⾏进程的切换，可分为两种情况：① 若⼀个时间⽚尚未⽤完，正在运⾏的进程便已经完成，就⽴即激活调度程序，将它从就绪队列中删除，再调度就绪队列中队⾸的进程运⾏，并启动⼀个新的时间⽚。

② 在⼀个时间⽚⽤完时，计时器中断处理程序被激活。

如果进程尚未运⾏完毕，调度程序将把它送往就绪队列的末尾。

2.运⾏结果四、实验代码public class Thread {int id;//进程IDint arrivetime;//到达时间int runtime;//运⾏时间int rmaintime;//剩余运⾏时间int endtime;//完成时间int turnovertime;//周转时间float qturnovertime;//带权周转时间public int getId() {return id;}public void setId(int id) {this.id = id;}public int getArrivetime() {return arrivetime;}public void setArrivetime(int arrivetime) {this.arrivetime = arrivetime;}public int getRuntime() {return runtime;}public void setRuntime(int runtime) {this.runtime = runtime;}public int getRmaintime() {return rmaintime;}public void setRmaintime(int rmaintime) {this.rmaintime = rmaintime;}public int getEndtime() {return endtime;}public void setEndtime(int endtime) {this.endtime = endtime;}public int getTurnovertime() {return turnovertime;}public void setTurnovertime(int turnovertime) {this.turnovertime = turnovertime;}public float getQturnovertime() {return qturnovertime;}public void setQturnovertime(float qturnovertime) {this.qturnovertime = qturnovertime;}public Thread() {id=0;arrivetime=0;//到达时间runtime=0;//运⾏时间rmaintime=0;//剩余运⾏时间endtime=0;//完成时间turnovertime=0;//周转时间qturnovertime=0;//带权周转时间}public Thread(int id, int arrivetime, int runtime,int rmaintime) { this.id = id;this.arrivetime = arrivetime;this.runtime = runtime;this.rmaintime=rmaintime;}@Overridepublic String toString() {return "Thread{" +"id=" + id +", arrivetime=" + arrivetime +", runtime=" + runtime +", rmaintime=" + rmaintime +'}';}}package com.hu;import java.util.Iterator;import java.util.LinkedList;import java.util.Random;public class Test {static final int slicetime=2;//时间⽚⼤⼩设为2public static void main(String[] args) {RR(InitQueue(SortThread(InitThread())));}public static void RR(LinkedList queue){int i=0;int count=0;for (Iterator iter = queue.iterator(); iter.hasNext();){System.out.println();Thread thread =(Thread) queue.getFirst();System.out.println(thread);if (thread.rmaintime<=slicetime){count=count+thread.rmaintime;//当前时间thread.endtime=count;//结束时间thread.turnovertime= thread.endtime-thread.arrivetime;//周转时间thread.qturnovertime=(float)thread.turnovertime/thread.runtime;//带权周转时间thread.rmaintime=0;System.out.println(thread.getId()+"号进程结束"+"结束时间："+thread.endtime+"周转时间："+thread.turnovertime+"带权周转时间："+thr ead.qturnovertime);queue.remove();}else {count=count+2;//当前时间thread.rmaintime=thread.rmaintime-slicetime;//执⾏进程queue.remove();queue.offer(thread);//时间⽚完插⼊队尾}}}public static Thread[] InitThread(){//初始化进程到达时间与运⾏时间Thread[] thread = new Thread[5];for (int i=0;i<thread.length;i++){Random random = new Random();int t= random.nextInt(10)+1;thread[i] = new Thread(i,random.nextInt(10)+1,t,t);}return thread;}public static Thread[] SortThread(Thread[] threads) {//进程排序for (int i = 0; i < threads.length; i++) {for (int j = 0; j < threads.length - 1; j++) {if (threads[j].arrivetime > threads[j + 1].arrivetime) {//如果进程到达时间不相等按进程的到达时间从⼩到⼤排序Thread t;t = threads[j];threads[j] = threads[j + 1];threads[j + 1] = t;}if (threads[j].arrivetime == threads[j + 1].arrivetime) {//如果进程到达时间相等按进程的运⾏时间从⼩到⼤排序if (threads[j].runtime > threads[j + 1].runtime) {Thread t;t = threads[j];threads[j] = threads[j + 1];threads[j + 1] = t;}}}}return threads;}public static LinkedList InitQueue(Thread[] threads){//初始化队列LinkedList<Thread> queue = new LinkedList<Thread>();for (int i=0;i< threads.length;i++){queue.offer(threads[i]);}return queue;}}。