操作系统课程设计时间片轮转算法java实现
操作系统 时间片轮转RR进程调度算法 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可视化模拟程序如何实现一个时间片轮转调度算法的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、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统课程设计时间片轮转算法j a v a实现 Document serial number【UU89WT-UU98YT-UU8CB-UUUT-UUT108】学校代码：10128课程设计题目：处理机管理模拟系统的设计与实现学生姓名：学院：信息工程学院系别：软件工程系专业：软件工程班级：指导教师：副教授讲师2013年1月8日内蒙古工业大学课程设计任务书（四）学院（系）：信息学院软件工程系课程名称：操作系统课程设计指导教师（签名）：专业班级：学生姓名：学号：摘要操作系统是计算机系统的关键组成部分，负责管理与配置内存、决定系统资源供需的优先次序、控制输入与输出设备、操作网络与管理文件系统等基本任务。
对于不同的系统和系统目标，通常采用不同的调度算法，如在批处理系统中，为照顾为数众多的短作业，采用短作业优先调度算法；在分时系统中，为保证系统具有合理的响应时间，采用时间片轮转法进行调度。
采用算法时，则要考虑多方面因素，以便达到最佳效果。
本次课程设计采用时间片轮转调度算法来实现模拟进程调度任务的执行过程。
用Java模拟进程调度过程，可以方便地将运行结果直观地表示出来。
Java语言独有的多线程操作，可以实现许多其他语言不能实现的功能，极大地方便了程序开发人员对程序的开发。
此外，利用JavaGUI编程，可以使系统提供的界面更加友好。
实验中，应用文件I/O操作、线程、AWT、Swing、内部类、接口、异常处理等技术，开发此系统。
关键字：时间片轮转； Java编程； GUI图形用户界面；文件操作；AbstractThe operating system is a key component of the computer system, responsible for the management and configuration memory, decided to system resources supply and demand priority, control input and output equipment, operation and management of network file system, and other basic different systems and system target, computers usually use different scheduling algorithm, such as in a Batch Processing System, in order to take care of a lot of short operation, using Short Job First algorithm;In systems with time sharing, to ensure the system has reasonable response time, need time slice Round Robin algorithm for scheduling. The algorithm, we should consider various factors, in order to achieve the best Course Design uses time slice Round Robin algorithm to simulate the process scheduling task execution process.With Java simulation process scheduling process, which can be conveniently will run results intuitively said addition, the use of JavaGUI programming, can make the system to provide theinterface more , application file I/O operation, threads, AWT, Swing, internal class, interface, abnormal processing technology, the development of this system.Keywords: time slice Round Robin; Java Programming; ;File Operation;目录第一章问题分析设计目的在多道程序或多任务系统中，系统同时处于就绪态的进程有若干个。
也就是说能运行的进程数远远大于处理机个数。
为了使系统中的各进程能有条不紊地运行，必须选择某种调度策略，以选择一进程占有处理机。
要求设计一个模拟单处理机调度的算法，以巩固和加深处理机调度的概念。
设计目标问题描述处理机管理是操作系统中非常重要的部分。
为深入理解处理机调度部分的功能，设计一个按时间片轮转调度CPU的算法，模拟实现处理机的调度。
基本要求时间片轮转调度CPU的算法是分时系统采用的典型算法，把CPU的执行时间分成若干个一定大小的时间片轮流的分配给就绪队列的各个进程，让各就绪进程按指定的顺序分别占用CPU的一个时间片轮流执行下去，直至完成。
要求定义进程控制块PCB的结构，并为每个进程任意确定一个要求运行时间和到达时间，按照进程到达的先后顺序排成一个循环队列。
设计按时间片轮转的进程调度算法。
设计思想和运行环境a.设计思想(1) 假设系统有5个进程，每个进程用一个进程控制块Process来代表。
Process的结构如图1-1所示。
对PCB控制块进行包装，形成循环链表结点ProcessNode，链表结点ProcessNode如图1-2所示。
(2) 为每个进程从模拟的系统中指定一个要求运行时间和到达时间。
(3) 按照进程到达的先后顺序排成一个循环队列，再设一个队首指针head指向第一个到达进程的首址。
(4) 执行处理机调度时，从队列的第一个进程开始，用pntmp指针顺序选择可执行的进程执行。
(5) 由于本实践是模拟算法，所以对被选中进程并不实际启动运行，而只是执行：运行时间加100和输出当前运行进程的相关信息。
用这两个操作来模拟进程的一次运行。
b.运行环境编程语言：Java语言工具：、Windows 7系统以及等第二章概要设计系统结构系统结构层次图图2-1处理机管理系统层次系统功能说明a.创建进程模块：创建进程模块在输入进程页面输入要创建的进程数，输入后逐个将进程信息录入插入到就绪队列中，完成进程的创建过程。
b.运行程序模块：此模块实现时间片轮转调度算法，从就绪队列中取出进程结点，并模拟运行该进程，反复循环，直至进程全部运行结束。
每次运行进程后，将运行信息存入到文件中，实现信息的持久化。
方便信息的记录，系统功能的分析和出错时便于检查错误。
c.显示结果模块：从文件中读入进程运行的结果，在图形界面下操作，提供友好的用户操作方式，方便直观的了解模拟进程的调度过程，便于数据分析和研究。
算法描述a.在创建进程界面将进程信息录入，将进程控制块进行包装，插入到循环队列中；b.当运行程序时，每次从就绪队列队首取出一个进程pntmp，判断是pntmp进程否到达。
到达则运行该进程；c.若pntmp进程为首次运行，则记录进程开始运行时间startTime；d.运行完pntmp进程后，输出进程运行信息，并将此结点移至队尾；e.若循环队列长度size>0,则返回执行b；否则结束程序；第三章详细设计系统程序流程图图3-1程序流程内部接口设计系统框架接口run（）public void run(){建框架frame置相关属性}增加面板组件接口addComponentsTpPane()public static void addComponentsTpPane(Container pane){置布局方式建系统功能按钮册按钮听按钮动作，并产生相应操作，执行对应的功能}创建进程接口createFrame()public static void createFrame(){class createInputFrame extends Frame implements ActionListener{ 建运行窗口界面int currenttime=0; 行时间片轮转调度算法，并记录信息}try { 建显示结果窗体JFrame jf=new JFrame("显示运行结果");开文件final JTextArea jta=new JTextArea(16,50);(new ActionListener(){public void actionPerformed(ActionEvent e) {文件内容读到文本框中}});}用户接口用户启动此处理机管理模拟系统后，即可方便的进行操作。
以下为用户使用此软件时的图形接口：a.系统主界面(图3-2)：b.进程创建页面（图3-3）：第四章系统实现编码实现系统采用高级语言Java设计实现，程序容易阅读，易于测试，容易调试，方便维护。
并且Java为当今最流行的编程语言，有其独到的优点；程序代码符合基本编程规范，方法，属性命名能体现程序的功能。
单元测试创建进程模块a.测试数据图3-3进程数num: 2进程名进程运行时间进程到达时间神舟1号800 0神舟2号300 100b.预期输出无输出结果，但创建进程模块将输入数据存入内存，并结束输入返回主界面。
c.运行结果①进程数输入界面（图4-1）：②进程信息输入界面（图4-2）：运行程序模块a. 测试数据进程数num:2 进程名 进程运行时间 进程到达时间 神舟1号 800 0 神舟2号300100b. 预期输出系统时间 进程名 剩余时间 已运行次数 进程状态周转时间 0神舟1号 7001true100200 神舟1号 600 2 true 300神州2号2001true400 神舟1号 500 3 true 500 神州2号 100 2 true 600神舟1号4004true图4-2700 神州2号 100 3 false 700800 神舟1号 300 5 true 900 神舟1号 200 6 true 1000 神舟1号 100 7 true 1100神舟1号1008false1200c. 运行结果（图4-3）结果显示模块a. 测试数据无需测试数据b. 预期输出文件正常打开，在终端显示相关控制信息及内容；在用户界面显示文件内进程运行时的信息内容及运行的结果；合法的输出；c. 运行结果（图4-4）图4-3图4-4遇到的问题1)布局管理器实现页面布局时，不能很好的显示在桌面上。