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

合集下载

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

宇文皓月课程设计题目：处理机管理模拟系统的设计与实现学生姓名：学院：信息工程学院系别：软件工程系专业：软件工程班级：指导教师：副教授讲师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 tasks.For 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 JobFirst algorithm;In systems with time sharing, to ensure the system has reasonable responsetime, need time slice Round Robin algorithm for scheduling. The algorithm, we should consider various factors, in order to achieve the best effect.This 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 out.In addition, the use of JavaGUI programming, can make the system to provide the interface more friendly.Experiments, 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;GraphicalUserInterface;File Operation;目录第一章问题分析------------------------------------------- 11.1设计目的11.2设计目标11.2.1问题描述11.2.2基本要求11.3设计思想和运行环境1第二章概要设计------------------------------------------- 32.1系统结构32.1.1系统结构条理图32.1.2系统功能说明32.2算法描述4第三章详细设计------------------------------------------- 53.1系统程序流程图53.2内部接口设计73.2.1系统框架接口run（）73.2.3创建进程接口createFrame()83.2.4运行程序接口runFrame() ------------------------ 83.2.5显示结果接口resultFrame()93.3用户接口9第四章系统实现------------------------------------------ 114.1编码实现114.2单元测试114.2.1创建进程模块114.2.2运行程序模块134.2.3结果显示模块144.3遇到的问题15第五章自我评价与总结------------------------------------ 16参考文献------------------------------------------------- 17第一章问题分析1.1设计目的在多道程序或多任务系统中，系统同时处于就绪态的进程有若干个。

实验二带优先级的时间片轮换的进程调度算法的实现

•
struct pcb *p;
•
for (i=0;i<MAXPIOR;i++)
•
{p=array[i];
•
while (p!=NULL)
•
{printf("id:%d,state:%d,pior:%d,life:%d\n",p->ident,p->state,p->pior,p->life);
•
p=p->next;
• {int i=0,ii=0;
• for (i=0;i<7;i++)
•
if (stricmp(str,command[i])==0)
•
break;
• switch(i)
•
{case 0:printf("thank you for using the program!\n");exit(0);
•
break;
•{
•
int i=MAXPIOR-1,pior=0,t;
•
struct pcb *pp,*qq,*pr,*r;
•
do
•
{
•
while (i>=0 && array[i]==NUf (i<0)
•
{
•
printf("NO process,please create it! \n");
第1个，再降低其优先级，插入到相应的队列中。 C）ps 查看当前进程状态 D）sleep 命令将进程挂起 E）awake 命令唤醒1个被挂起的进程 F）kill 命令杀死进程 G）quit命令退出（4）选用面向对象的编程方法。

计算机操作系统时间片循环轮转算法

计算机操作系统时间片循环轮转算法实验报告书课程名：《计算机操作系统》题目：时间片循环轮转调度班级：软件081班学号：**********名：***(4) 处理器调度总是选择标志单元指示的进程运行。

由于本实验是模拟处理器调度的功能，因此，对被选中的进程并不实际的启动运行，而是执行：已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位的时间。

请注意：在实际的系统中，当一个进程被选中运行时，务必置上该进程能够运行的时间片值，与恢复进程的现场，让它占有处理器运行，直到出现等待事件或者运行满一个时间片。

在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。

(5) 进程运行一次后，应把该进程的进程操纵块中的指针值送到标志单元，以指示下一个轮到运行的进程。

同时，应推断该进程的要求运行时间与已运行时间，若该进程的要求运行时间已运行时间，则表示它尚未执行结束，应待到下一轮时再运行。

若该进程的要求运行时间=已运行时间，则表示它已经执行结束，应指导它的状态修改成“结束”（E）且退出队列。

如今，应把该进程的进程操纵块中的指针值送到前面一个进程的指针位置。

(6) 若“就绪”状态的进程队列不为空，则重复上面的（4）与（5）的步骤，直到所有的进程都成为“结束”状态。

(7) 在所设计的程序中应有显示或者打印语句，能显示或者打印每次选中进程的进程名与运行一次后进程队列的变化。

(8) 为五个进程任意确定一组“要求运行时间”，启动所设计的处理器调度程序，显示或者打印逐次被选中的进程名与进程操纵块的动态变化过程。

五、流程图与源程序int ProcNum; // 总进程个数// 初始化就绪队列void InitPCB(Proc &H) {cout<<"请输入总进程个数: ";cin>>ProcNum; // 进程总个数int Num=ProcNum;H=(Proc)malloc(sizeof(PNode)); // 建立头节点H->next=NULL;Proc p=H; //定义一个指针cout<<"总进程个数为 "<<ProcNum<<" 个,请依次输入相应信息\n\n";while (Num--) {p=p->next=(Proc)malloc(sizeof(PNode));cout<<"进程名总运行时间已运行时间 :";cin>>p->name>>p->All_Time>>p->Runed_Time;p->state='R';p->next=NULL;}p->next=H->next;}//输出运行中的进程信息void DispInfo(Proc H) {Proc p=H->next;do {if (p->state != 'E') //假如该进程的状态不是End的话{cout<<"进程名:"<<p->name<<"\t总运行时间:"<<p->All_Time <<"\t已运行时间:"<<p->Runed_Time<<"\t状态:"<<p->state<<endl;p=p->next;}else p=p->next;} while (p != H->next); // 整个进程链条始终完整，只是状态位有差异}// 时间片轮转法void SJP_Simulator(Proc &H) {cout<<endl<<"-------------------START--------------------\n";int flag=ProcNum; // 记录剩余进程数int round=0; // 记录轮转数Proc p=H->next;while (p->All_Time > p->Runed_Time) { // 即未结束的进程round++;cout<<endl<<"Round "<<round<<"--正在运行 "<<p->name<<" 进程"<<endl; p->Runed_Time++; // 更换正在运行的进程的已运行时间DispInfo(H); // 输出如今为就绪状态的进程的信息if (p->All_Time == p->Runed_Time) { // 并推断该进程是否结束p->state='E';flag--;cout<<p->name<<" 进程已运行结束,进程被删除!\n";}p=p->next;while (flag && p->All_Time == p->Runed_Time)p=p->next; // 跳过先前已结束的进程}cout<<endl<<"--------------------END---------------------\n";}void main() {Proc H;InitPCB(H); // 数据初始化DispInfo(H); // 输出此刻的进程状态SJP_Simulator(H); // 时间片轮转法system("pause");}六、测试数据与实验结果七、结果分析与实验体会时间片轮转算法中，系统将所有的就绪程序按先来先服务的原则排成一个队列，每次调度时，把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来代表。

操作系统实验(时间片轮转)

操作系统
实
验
报
告
实验名称：时间片轮转调度
班级：
姓名：
学号：
实验目的：用高级语言编写和调试一个简单的时间片轮转调度程序。

实验内容：（1）用户输入进程，每一个进程用一个进程控制块PCB 来代表。

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

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

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

实验步骤：
一、输入运行进程数目（测试数据为3）；
二、输入选择项（选择时间片轮转调度R）；
三、输入进程名称和服务时间；
实验结果：。

操作系统课程设计时间片轮转

目录一、设计目的 (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。

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

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

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

操作系统实验：时间片轮转RR进程调度算法

实验报告：时间片轮转RR进程调度算法题目：时间片轮转算法的实现班级：软件工程2班姓名：代其全学号：1025111022 完成日期：2012/10/23一．需求分析程序要实现时间片轮转进程调度算法（1）接收用户输入的进程数（n）,，各个进程的进程名，到达时间(T1…Tn)和服务时间(S1….Sn)，以及时间片大小q。

（2）输出各个进程首次运行的时间（3）输出各个进程的完成时间，周转时间，带权周转时间，所有进程的平均周转时间，以及带权平均周转时间。

（4）测试数据为: 进程数n为5, 各进程的名字，到达时间，服务时间分别为：a 0 4 ; b 1 3; c 2 5; d 3 2; e 4 4。

时间片大小q为1 和5。

二．概要设计抽象数据类型的定义：int ArrivalTime[100];//到达时间int ServiceTime[100];//服务时间int FinishTime[100];//完成时间int WholeTime[100];//周转时间double WeightWholeTime[100];//带权周转时间double AverageWT,AverageWWT;bool Finished[100];//完成标识typedef struct QNode{char name; //进程标识int arrivaltime;//到达时间int servicetime;//服务时间int workedtime; //进程已经运行的时间bool status; //表示进程的状态,1表示已经结束，0表示还未执行struct QNode *next;}QNode, *QueuePtr;typedef struct{QueuePtr front;//队头指针QueuePtr rear;//队尾指针}LinkQueue;主程序的流程：调用Init()函数初始化到达时间，服务时间，时间片等进程信息，调度RR（）函数实现轮转调度发，最后调度print()函数输出运算结果三．详细设计1.初始化函数void init(){int cputime;int x,y;char name;cout<<"请输入进程的个数:";cin>>n; //进程个数cout<<endl;for(int i=0;i<n;i++){QNode node;cout<<"请输入第"<<i+1<<"个进程的名字、到达时间和服务时间:";cin>>name>>x>>y;=name;node.arrivaltime=ArrivalTime[i]=x;node.servicetime=ServiceTime[i]=y;node.workedtime=0;node.status=Finished[i]=0;node.next=NULL;array[i]=node;//cout<<"队中增加一个元素"<<endl;cout<<endl;}//各个进程的到达时间和服务时间cout<<"请输入时间片大小:";cin>>cputime;q=cputime;//时间片大小}2.RR()函数void RR(){int temp;QNode e;int count1=0;//按到达时间先后排序进程信息数组for(int i=0;i<n;i++){for(int j=1;j<n-i;j++){if(array[i].arrivaltime>array[i+1].arrivaltime){temp=array[i].arrivaltime;array[i].arrivaltime=array[i+1].arrivaltime;array[i].arrivaltime=temp;}}}//此时，array数组中的元素都是按到达时间从小到大排列的for(i=0;i<n;i++){if(Finished[i]==0){count1++;}}for(int j=0;j<n;j++)if(array[j].arrivaltime==currentTime)EnQueue(queue,array[j]);//将到达时间为当前时间的进程加入到队列中if(count1!=0)//依然有进程未完成{for(int j=0;j<n;j++){if(q>=(*queue.front->next).servicetime)//时间片大于进程服务时间时，进程一次性执行完，进入下一进程{//cout<<"";cout<<"时刻"<<currentTime<<":进程"<<queue.front->next->name<<"开始执行"<<endl;for(int x=0;x<(*queue.front->next).servicetime;x++){currentTime++;for(int y=0;y<n;y++)if(array[y].arrivaltime==currentTime)EnQueue(queue,array[y]);//将到达时间为当前时间的进程加入到队列中}(*queue.front).status=1;//将此进程状态标注为已执行// currentTime=currentTime+(*queue.front->next).servicetime;//更新当前时间cout<<"当前时间为:"<<currentTime<<endl;DeQueue(queue,e);//将此进程出队count++;Finished[count]=1;FinishTime[count]=currentTime;//当前时间为完成时间，返回存放入FinishTime[]数组中}else//时间片小于服务时间时{if((*queue.front->next).workedtime<(*queue.front->next).servicetime)//进程已工作时间小于服务时间时{if((*queue.front->next).workedtime==0)//进程已工作时间为零时{// cout<<"";cout<<"时刻"<<currentTime<<":进程"<<(*queue.front->next).name<<"开始执行"<<endl;// currentTime=currentTime+q;//更新当前时间for(int x=0;x<q;x++){currentTime++;for(int j=0;j<n;j++)if(array[j].arrivaltime==currentTime)EnQueue(queue,array[j]);//将到达时间为当前时间的进程加入到队列中}(*queue.front->next).workedtime+=q;//更新进程已工作时间DeQueue(queue,e);//将该进程出队EnQueue(queue,e);//将该进程入队，加入到了队列的末尾}else//进程工作时间不为零且未达到服务时间时{for(inti=0;i<q&&(*queue.front->next).workedtime!=(*queue.front->next).servicetime;i+ +){currentTime++;//当前时间加一for(int j=0;j<n;j++)if(array[j].arrivaltime==currentTime)EnQueue(queue,array[j]);//将到达时间为当前时间的进程加入到队列中if((*queue.front->next).workedtime==(*queue.front->next).servicetime)//已工作时间达到要求的服务时间{(*queue.front->next).status=1;count++;Finished[count]=1;DeQueue(queue,e);FinishTime[count]=currentTime;//当前时间为完成时间，返回存放入FinishTime[]数组中}}}}}}}}3.输出函数void print(int n){cout<<"完成时间:";for(int i=0;i<n;i++)cout<<FinishTime[i]<<" ";cout<<endl;cout<<"周转时间:"<<" ";for(i=0;i<n;i++){WholeTime[i]=FinishTime[i]-ArrivalTime[i];cout<<WholeTime[i]<<" ";}cout<<endl;cout<<"带权周转时间:";for(i=0;i<n;i++){WeightWholeTime[i]=double(WholeTime[i])/ServiceTime[i];cout<<WeightWholeTime[i]<<" ";}cout<<endl;for(i=1;i<n;i++){WholeTime[0]+=WholeTime[i];}AverageWT=double(WholeTime[0])/n;cout<<"平均周转时间"<<AverageWT<<endl;for(i=1;i<n;i++){WeightWholeTime[0]+=WeightWholeTime[i];}AverageWWT=WeightWholeTime[0]/n;cout<<"带权平均周转时间:"<<AverageWWT<<endl; }4.队列里封装的函数int InitQueue(LinkQueue &q){q.front=q.rear=(QueuePtr)malloc(sizeof(QNode));if(!q.front)return 0;q.front->next=NULL;return 1;}int EnQueue(LinkQueue &q,QNode &e){QueuePtr p=(QueuePtr)malloc(sizeof(QNode));if(!p)return 0;p->name=;p->arrivaltime=e.arrivaltime;p->servicetime=e.servicetime;p->status=e.status;p->workedtime=e.workedtime;p->next=NULL;q.rear->next=p;q.rear=p;return 1;}int DeQueue(LinkQueue &q,QNode &e){if(q.rear==q.front)return 0;QueuePtr p=q.front->next;=p->name;e.arrivaltime=p->arrivaltime;e.servicetime=p->servicetime;e.status=p->status;e.workedtime=p->workedtime;q.front->next=p->next;if(q.rear==p)q.rear=q.front;free(p);return 1;}四．调试分析在时间片大于所有进程的服务时间时，程序正常运行，当时间片小于某些进程的服务时间时，程序不能输出正确的运算结果。

RR时间片轮转算法（java）

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（时间片轮转）

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;}。

时间片轮转

实验报告课程名称操作系统学生所在系部年级专业、班级学生姓名学号任课教师实验成绩软件工程系制一、实验题目：进程调度算法模拟程序设计二、实验目的：通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。

三、实验设备及环境：1. 硬件设备：PC机一台2. 软件环境：安装Windows操作系统或者Linux操作系统，并安装相关的程序开发环境，如C \C++\Java 等编程语言环境。

四、实验内容及要求：（1）用C语言编程实现对N个进程采用先来先服务算法调度执行的模拟。

（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：✧进程标识数ID。

✧进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。

✧进程已占用CPU时间CPUTIME。

✧进程还需占用的CPU时间ALLTIME。

当进程运行完毕时，ALLTIME变为0。

✧进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。

✧进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。

✧进程状态STA TE。

✧队列指针NEXT，用来将PCB排成队列。

（3）优先数改变的原则：✧进程在就绪队列中呆一个时间片，优先数增加1。

✧进程每运行一个时间片，优先数减3。

（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。

（5）分析程序运行的结果，谈一下自己的认识。

五、实验方法内容1.算法流程图2.主要的常量变量int ID;int ReachTime;int TotalTime;PCB A[M];PCB a[M];NOTE temp;int queue[50];};3.主要模块void insert(PCB *p) //时间片插入函数void create() //时间片算法创建进程函数void roundrobin() //时间片算法函数void firstin() //运行就绪队列的第一个进程四．代码#include "iostream.h"#include "string.h"#include "stdlib.h"typedef struct node {char name[10];//进程名int Time_piece;//时间片int Need_time;//还需要的时间int Count;//计数器char State;//进程的状态struct node *next;//链指针int Arrive_time;//到达时间}PCB;//run为当前运行进程指针,start为就绪队列头指针//end为就绪队列尾指针,finish为完成队列头指针PCB *run,*start,*end,*finish;int N;//进程个数int Cpu_time;//需要的CPU时间void insert(PCB *p){ //时间片插入函数if(start->next==NULL){PCB *q=start;if(p->Arrive_time<q->Arrive_time){start=p;p->next=q;q->next=NULL;end=q;}else{q->next=p;p->next=NULL;end=p;}}else{PCB *q=start;PCB *s=start->next;while(s!=NULL){if(q->Arrive_time>p->Arrive_time){p->next=q;start=p;return;}else{if(s->Arrive_time>p->Arrive_time){q->next=p;p->next=s;return;}else{q=q->next;s=s->next;}}}s->next=p;end=p;}}void insert2(PCB *p){end->next=p; //将新的PCB插入在当前就绪队列的尾end=p;p->next=NULL;}void show(PCB *p)//输出函数{cout<<" 进程名到达时间剩余时间状态\n";// if(run!=NULL)//如果运行指针不为空,就输出当前正在运行的进程的PCB{ cout<<" "<<p->name<<"\t "<<p->Arrive_time<<"\t"<<p->Need_time<<"\t "<<p->State<<"\n";}}void create()//时间片算法创建进程函数{cout<<"请输入所需要运行的进程个数: ";cin>>N;PCB *p;int Time_piece;start=NULL; //就绪队列头指针finish=NULL; //完成队列头指针run=NULL; //运行队列指针cout<<"请输入时间片长度: ";cin>>Time_piece;for(int i=1;i<=N;i++){ //输入进程名字和所需时间,创建进程的PCB p=(PCB *)malloc(sizeof(PCB));cout<<"请输入第"<<i<<"个进程的名字:";cin>>p->name;cout<<" 预计运行的时间:";cin>>p->Need_time;cout<<" 到达时间:";cin>>p->Arrive_time;Cpu_time=0;p->Count=0;//计数器p->State='P';//进程的初始状态设为就绪'W'p->Time_piece=Time_piece;//时间片的初始值if(start!=NULL){insert(p);//若就绪队列不为空,将其插入就绪队列}else{ //创建就绪队列的第一个PCBp->next=start;start=p;//头指针end=p; //尾指针}}cout<<endl<<endl<<"\t 使用时间片轮转算法输出结果:\n";cout<<"*********************************************************\n"; run=start; //将就绪队列的第一个进程投入运行start=start->next;run->State='W';}void firstin(){ //将就绪队列的第一个进程放入运行队列run=start;run->State='W';//改变其状态start=start->next;}void roundrobin(){ //时间片算法函数int m=0;while(run!=NULL){if(run->Arrive_time>Cpu_time){Cpu_time=Cpu_time+1;//每运行一次cputime加一}else{if(m==0){cout<<"~~~~~~~~~~~~~~~~~~~~~~~~进程"<<run->name<<"开始啦~~~~~~~~~~~~~~~~~~~~~~~\n";m++;}run->Need_time=run->Need_time-1;//每运行一次needtime减一if(run->Need_time!=0)show(run);Cpu_time=Cpu_time+1;//每运行一次cputime加一run->Count=run->Count+1;//每运行一次计数器count加一if(run->Need_time==0){ //若运行完后run->next=finish;finish=run;//将其插入完成队列头部run->State='F';//将其状态改为完成态"F"show(run);cout<<"~~~~~~~~~~~~~~~~~~~~~~~~进程"<<run->name<<"结束啦~~~~~~~~~~~~~~~~~~~~~~~\n";run=NULL;//将运行队列清空if(start!=NULL) {firstin(); //若就绪对列不空，将第一个进程投入运行cout<<"~~~~~~~~~~~~~~~~~~~~~~~~进程"<<run->name<<"开始啦~~~~~~~~~~~~~~~~~~~~~~~\n";}}else{if(run->Count==run->Time_piece){ //如果时间片到run->Count=0; //计数器置0if(start!=NULL){ //若就绪队列不空run->State='W';insert2(run);//将进程插入到就绪队列中等待轮转firstin(); //将就绪队列的第一个进程投入运行cout<<"~~~~~~~~~~~~~~~~~~~~~~~~进程"<<run->name<<"开始啦~~~~~~~~~~~~~~~~~~~~~~~\n";}}}}}cout<<"*********************************************************\n";} void main(){ //主函数create(); //建立就绪队列roundrobin(); //调用时间片轮转调度算法的函数}MFC版：void CYanDlg::OnButton2() {UpdateData(TRUE);PCB *p;if(i<N){ //输入进程名字和所需时间,创建进程的PCBp=(PCB *)malloc(sizeof(PCB));cputime=0;p->arrivetime=m_arrivetime;p->needtime=m_runtime;p->name=m_name;p->count=0;//计数器p->state='P';p->time=T;//时间片赋值if(ready!=NULL){In1(p);//若就绪队列不为空,将其插入就绪队列}else{ //创建就绪队列的第一个PCBp->next=ready;ready=p;//头指针tail=p; //尾指针}i++;Show(p);if(i==N){m_show+="~~~~~~~~~~~~~~~~~~~~~~~~~~~完成~~~~~~~~~~~~~~~~~~~~~~~~\r\n";m_show+="\r\n";}}if(i==N){run=ready; //将就绪队列的第一个进程投入运行ready=ready->next;run->state='W';}UpdateData(false);}void CYanDlg::In1(PCB *p){if(ready->next==NULL){PCB *q=ready;if(p->arrivetime<q->arrivetime){ready=p;p->next=q;q->next=NULL;tail=q;}else{q->next=p;p->next=NULL;tail=p;}}else{PCB *q=ready;PCB *s=ready->next;while(s!=NULL){if(q->arrivetime>p->arrivetime){p->next=q;ready=p;return;}else{if(s->arrivetime>p->arrivetime){q->next=p;p->next=s;return;}else{q=q->next;s=s->next;}}}s->next=p;tail=p;}}void CYanDlg::OnButton3() { //时间片算法调用程序while(run!=NULL){if(run->arrivetime>cputime){cputime=cputime+1;}else{if(i==N){m_show+="~~~~~~~~~~~~~~~~~~~~~~~~进程"+(CString)(run->name+'0')+"开始啦~~~~~~~~~~~~~~~~~~~~~~~\r\n\r\n";i++;}run->needtime=run->needtime-1;if(run->needtime!=0)Show(run); //输出进程信息cputime=cputime+1;run->count=run->count+1;if(run->needtime==0){ //运行完成run->next=finish;finish=run;run->state='F';Show(run);m_show+="~~~~~~~~~~~~~~~~~~~~~~~~进程"+(CString)(run->name+'0')+"结束啦~~~~~~~~~~~~~~~~~~~~~~~\r\n";run=NULL;if(ready!=NULL) {InFirst(); //若就绪对列不空，将第一个进程投入运行m_show+="\r\n";m_show+="~~~~~~~~~~~~~~~~~~~~~~~~进程"+(CString)(run->name+'0')+"开始啦~~~~~~~~~~~~~~~~~~~~~~~\r\n\r\n";}}elseif(run->count==run->time){ //时间片结束run->count=0; //计数器置0if(ready!=NULL){ //若就绪队列不空run->state='P';In2(run);//将进程插入到就绪队列等待轮转InFirst(); //将就绪队列的第一个进程投入运行}m_show+="\r\n";m_show+="~~~~~~~~~~~~~~~~~~~~~~~~进程"+(CString)(run->name+'0')+"开始啦~~~~~~~~~~~~~~~~~~~~~~~\r\n\r\n";}}}UpdateData(false);}六、实验结果1.执行结果2.结果分析首先，将进程1,2依次输入PCB并输出他们的信息，如图2。

java简单手写版本实现时间轮算法

java简单⼿写版本实现时间轮算法时间轮关于时间轮的介绍,⽹上有很多,这⾥就不重复了核⼼思想⼀个环形数组存储时间轮的所有槽(看你的⼿表),每个槽对应当前时间轮的最⼩精度超过当前时间轮最⼤表⽰范围的会被丢到上层时间轮,上层时间轮的最⼩精度即为下层时间轮能表达的最⼤时间(时分秒概念)每个槽对应⼀个环形链表存储该时间应该被执⾏的任务需要⼀个线程去驱动指针运转,获取到期任务以下给出java 简单⼿写版本实现代码实现时间轮主数据结构/*** @author apdoer* @version 1.0* @date 2021/3/22 19:31*/@Slf4jpublic class TimeWheel {/*** ⼀个槽的时间间隔(时间轮最⼩刻度)*/private long tickMs;/*** 时间轮⼤⼩(槽的个数)*/private int wheelSize;/*** ⼀轮的时间跨度*/private long interval;private long currentTime;/*** 槽*/private TimerTaskList[] buckets;/*** 上层时间轮*/private volatile TimeWheel overflowWheel;/*** ⼀个timer只有⼀个delayqueue*/private DelayQueue<TimerTaskList> delayQueue;public TimeWheel(long tickMs, int wheelSize, long currentTime, DelayQueue<TimerTaskList> delayQueue) {this.currentTime = currentTime;this.tickMs = tickMs;this.wheelSize = wheelSize;this.interval = tickMs * wheelSize;this.buckets = new TimerTaskList[wheelSize];this.currentTime = currentTime - (currentTime % tickMs);this.delayQueue = delayQueue;for (int i = 0; i < wheelSize; i++) {buckets[i] = new TimerTaskList();}}public boolean add(TimerTaskEntry entry) {long expiration = entry.getExpireMs();if (expiration < tickMs + currentTime) {//到期了return false;} else if (expiration < currentTime + interval) {//扔进当前时间轮的某个槽⾥,只有时间⼤于某个槽,才会放进去long virtualId = (expiration / tickMs);int index = (int) (virtualId % wheelSize);TimerTaskList bucket = buckets[index];bucket.addTask(entry);//设置bucket 过期时间if (bucket.setExpiration(virtualId * tickMs)) {//设好过期时间的bucket需要⼊队delayQueue.offer(bucket);return true;}} else {//当前轮不能满⾜,需要扔到上⼀轮TimeWheel timeWheel = getOverflowWheel();return timeWheel.add(entry);}return false;}private TimeWheel getOverflowWheel() {if (overflowWheel == null) {synchronized (this) {if (overflowWheel == null) {overflowWheel = new TimeWheel(interval, wheelSize, currentTime, delayQueue); }}}return overflowWheel;}/*** 推进指针** @param timestamp*/public void advanceLock(long timestamp) {if (timestamp > currentTime + tickMs) {currentTime = timestamp - (timestamp % tickMs);if (overflowWheel != null) {this.getOverflowWheel().advanceLock(timestamp);}}}}定时器接⼝/*** 定时器* @author apdoer* @version 1.0* @date 2021/3/22 20:30*/public interface Timer {/*** 添加⼀个新任务** @param timerTask*/void add(TimerTask timerTask);/*** 推动指针** @param timeout*/void advanceClock(long timeout);/*** 等待执⾏的任务** @return*/int size();/*** 关闭服务,剩下的⽆法被执⾏*/void shutdown();}定时器实现/*** @author apdoer* @version 1.0* @date 2021/3/22 20:33*/@Slf4jpublic class SystemTimer implements Timer {/*** 底层时间轮*/private TimeWheel timeWheel;/*** ⼀个Timer只有⼀个延时队列*/private DelayQueue<TimerTaskList> delayQueue = new DelayQueue<>();/*** 过期任务执⾏线程*/private ExecutorService workerThreadPool;/*** 轮询delayQueue获取过期任务线程*/private ExecutorService bossThreadPool;public SystemTimer() {this.timeWheel = new TimeWheel(1, 20, System.currentTimeMillis(), delayQueue);this.workerThreadPool = Executors.newFixedThreadPool(100);this.bossThreadPool = Executors.newFixedThreadPool(1);//20ms推动⼀次时间轮运转this.bossThreadPool.submit(() -> {for (; ; ) {this.advanceClock(20);}});}public void addTimerTaskEntry(TimerTaskEntry entry) {if (!timeWheel.add(entry)) {//已经过期了TimerTask timerTask = entry.getTimerTask();("=====任务:{} 已到期,准备执⾏============",timerTask.getDesc());workerThreadPool.submit(timerTask);}}@Overridepublic void add(TimerTask timerTask) {("=======添加任务开始====task:{}", timerTask.getDesc());TimerTaskEntry entry = new TimerTaskEntry(timerTask, timerTask.getDelayMs() + System.currentTimeMillis()); timerTask.setTimerTaskEntry(entry);addTimerTaskEntry(entry);}/*** 推动指针运转获取过期任务** @param timeout 时间间隔* @return*/@Overridepublic synchronized void advanceClock(long timeout) {try {TimerTaskList bucket = delayQueue.poll(timeout, LISECONDS);if (bucket != null) {//推进时间timeWheel.advanceLock(bucket.getExpiration());//执⾏过期任务(包含降级)bucket.clear(this::addTimerTaskEntry);}} catch (InterruptedException e) {log.error("advanceClock error");}}@Overridepublic int size() {//todoreturn 0;}@Overridepublic void shutdown() {this.bossThreadPool.shutdown();this.workerThreadPool.shutdown();this.timeWheel = null;}}存储任务的环形链表/*** @author apdoer* @version 1.0* @date 2021/3/22 19:26*/@Data@Slf4jclass TimerTaskList implements Delayed {/*** TimerTaskList 环形链表使⽤⼀个虚拟根节点root*/private TimerTaskEntry root = new TimerTaskEntry(null, -1);{root.next = root;root.prev = root;}/*** bucket的过期时间*/private AtomicLong expiration = new AtomicLong(-1L);public long getExpiration() {return expiration.get();}/*** 设置bucket的过期时间,设置成功返回true** @param expirationMs* @return*/boolean setExpiration(long expirationMs) {return expiration.getAndSet(expirationMs) != expirationMs;}public boolean addTask(TimerTaskEntry entry) {boolean done = false;while (!done) {//如果TimerTaskEntry已经在别的list中就先移除,同步代码块外⾯移除,避免死锁,⼀直到成功为⽌ entry.remove();synchronized (this) {if (entry.timedTaskList == null) {//加到链表的末尾entry.timedTaskList = this;TimerTaskEntry tail = root.prev;entry.prev = tail;entry.next = root;tail.next = entry;root.prev = entry;done = true;}}}return true;}/*** 从 TimedTaskList 移除指定的 timerTaskEntry** @param entry*/public void remove(TimerTaskEntry entry) {synchronized (this) {if (entry.getTimedTaskList().equals(this)) {entry.next.prev = entry.prev;entry.prev.next = entry.next;entry.next = null;entry.prev = null;entry.timedTaskList = null;}}}/*** 移除所有*/public synchronized void clear(Consumer<TimerTaskEntry> entry) {TimerTaskEntry head = root.next;while (!head.equals(root)) {remove(head);entry.accept(head);head = root.next;}expiration.set(-1L);}@Overridepublic long getDelay(TimeUnit unit) {return Math.max(0, unit.convert(expiration.get() - System.currentTimeMillis(), LISECONDS)); }@Overridepublic int compareTo(Delayed o) {if (o instanceof TimerTaskList) {return pare(expiration.get(), ((TimerTaskList) o).expiration.get());}return 0;}}存储任务的容器entry/*** @author apdoer* @version 1.0* @date 2021/3/22 19:26*/@Dataclass TimerTaskEntry implements Comparable<TimerTaskEntry> {private TimerTask timerTask;private long expireMs;volatile TimerTaskList timedTaskList;TimerTaskEntry next;TimerTaskEntry prev;public TimerTaskEntry(TimerTask timedTask, long expireMs) {this.timerTask = timedTask;this.expireMs = expireMs;this.next = null;this.prev = null;}void remove() {TimerTaskList currentList = timedTaskList;while (currentList != null) {currentList.remove(this);currentList = timedTaskList;}}@Overridepublic int compareTo(TimerTaskEntry o) {return ((int) (this.expireMs - o.expireMs));}}任务包装类(这⾥也可以将⼯作任务以线程变量的⽅式去传⼊)@Data@Slf4jclass TimerTask implements Runnable {/*** 延时时间*/private long delayMs;/*** 任务所在的entry*/private TimerTaskEntry timerTaskEntry;private String desc;public TimerTask(String desc, long delayMs) {this.desc = desc;this.delayMs = delayMs;this.timerTaskEntry = null;}public synchronized void setTimerTaskEntry(TimerTaskEntry entry) {// 如果这个timetask已经被⼀个已存在的TimerTaskEntry持有,先移除⼀个if (timerTaskEntry != null && timerTaskEntry != entry) {timerTaskEntry.remove();}timerTaskEntry = entry;}public TimerTaskEntry getTimerTaskEntry() {return timerTaskEntry;}@Overridepublic void run() {("============={}任务执⾏", desc);}}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

实验一时间片轮转进程调度算法

实验一时间片轮转进程调度算法时间片轮转（Round Robin）是一种常见的进程调度算法，其核心思想是每个进程被分配一个时间片，当时间片用完时，CPU会切换到下一个进程。

这种算法简单高效，能够保证每个进程都能获得公平的CPU时间。

在时间片轮转算法中，每个进程被分配一个相同大小的时间片，通常为几十毫秒到几百毫秒不等。

当一个进程占用完了其时间片，CPU会将其放入就绪队列的末尾，并将CPU分配给队列中的下一个进程。

这种方式可以确保每个进程都有机会运行，并且不会出现某个进程长时间占用CPU，导致其他进程饥饿的情况。

时间片轮转算法的优点之一是简单易实现，只需要设置一个固定的时间片大小和一个就绪队列即可。

另外，由于每个进程都有相同的时间片，因此可以较好地保证公平性，避免某个进程长时间占用CPU而导致其他进程无法运行的情况。

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

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

而如果时间片设置过大，可能会出现某些进程长时间占用CPU的情况，降低了系统的响应速度。

因此，选择合适的时间片大小对系统的性能至关重要。

另外，时间片轮转算法对I/O密集型的进程并不友好。

由于I/O操作需要等待外部设备的响应，进程可能会在I/O操作期间主动放弃CPU，这样会导致进程在等待I/O时浪费了部分时间片。

为了解决这个问题，可以考虑将I/O操作的等待时间纳入时间片，或者采用其他更适合I/O密集型进程的调度算法。

总的来说，时间片轮转算法是一种简单高效的进程调度算法，适用于大多数情况下。

在实际应用中，需要根据系统的特点和需求选择合适的时间片大小，以提高系统的性能和响应速度。

同时，针对不同类型的进程可以结合其他调度算法，以达到更好的效果。

操作系统时间片轮转算法与优先级调度算法

#include "stdio.h"#include "stdlib.h"#include "string.h"typedef struct node{char name[10]; /*进程标识符*/int prio; /*进程优先数*/int round; /*进程时间轮转时间片*/int cputime; /*进程占用CPU时间*/int needtime; /*进程到完成还要的时间*/int count; /*计数器*/char state; /*进程的状态*/struct node *next; /*链指针*/}PCB;PCB *finish,*ready,*tail,*run; /*队列指针*/int N; /*进程数*//*将就绪队列中的第一个进程投入运行*/firstin(){run=ready; /*就绪队列头指针赋值给运行头指针*/run->state='R'; /*进程状态变为运行态*/ready=ready->next; /*就绪对列头指针后移到下一进程*/}/*标题输出函数*/void prt1(char a){if(toupper(a)=='P') /*优先数法*/printf(" name cputime needtime priority state\n");elseprintf(" name cputime needtime count round state\n"); }/*进程PCB输出*/void prt2(char a,PCB *q){if(toupper(a)=='P') /*优先数法的输出*/printf(" %-10s%-10d%-10d%-10d %c\n",q->name,q->cputime,q->needtime,q->prio,q->state);else/*轮转法的输出*/printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,q->cputime,q->needtime,q->count,q->round,q->state);}/*输出函数*/void prt(char algo){PCB *p;prt1(algo); /*输出标题*/if(run!=NULL) /*如果运行指针不空*/prt2(algo,run); /*输出当前正在运行的PCB*/p=ready; /*输出就绪队列PCB*/while(p!=NULL){prt2(algo,p);p=p->next;}p=finish; /*输出完成队列的PCB*/while(p!=NULL){prt2(algo,p);p=p->next;}p=ready;printf("就绪队列：");while(p!=NULL){printf("%s\t",p->name); p=p->next;}printf("\n");p=finish;printf("完成队列：");while(p!=NULL){printf("%s\t",p->name); p=p->next;}printf("\n");getch(); /*压任意键继续*/ }/*优先数的插入算法*/insert1(PCB *q){PCB *p1,*s,*r;int b;s=q; /*待插入的PCB指针*/p1=ready; /*就绪队列头指针*/r=p1; /*r做p1的前驱指针*/b=1;while((p1!=NULL)&&b) /*根据优先数确定插入位置*/if(p1->prio>=s->prio){r=p1;p1=p1->next;}elseb=0;if(r!=p1) /*如果条件成立说明插入在r与p1之间*/{r->next=s;s->next=p1;}else{s->next=p1; /*否则插入在就绪队列的头*/ready=s;}}/*轮转法插入函数*/insert2(PCB *p2){tail->next=p2; /*将新的PCB插入在当前就绪队列的尾*/ tail=p2;p2->next=NULL;}/*优先数创建初始PCB信息*/void create1(char alg){PCB *p;int i,time;char na[10];ready=NULL; /*就绪队列头指针*/finish=NULL; /*完成队列头指针*/run=NULL; /*运行队列指针*/printf("Enter name and time of process\n"); /*输入进程标识和所需时间创建PCB*/for(i=1;i<=N;i++){p=malloc(sizeof(PCB));scanf("%s",na);scanf("%d",&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->state='W';p->prio=50-time;if(ready!=NULL) /*就绪队列不空调用插入函数插入*/insert1(p);else{p->next=ready; /*创建就绪队列的第一个PCB*/ready=p;}}// clrscr();system("CLS");printf(" output of priority:\n");printf("************************************************\n"); prt(alg); /*输出进程PCB信息*/run=ready; /*将就绪队列的第一个进程投入运行*/ready=ready->next;run->state='R';}/*轮转法创建进程PCB*/void create2(char alg){PCB *p;int i,time;char na[10];ready=NULL;finish=NULL;run=NULL;printf("Enter name and time of round process\n");for(i=1;i<=N;i++){p=malloc(sizeof(PCB));scanf("%s",na);scanf("%d",&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->count=0; /*计数器*/p->state='W';p->round=2; /*时间片*/if(ready!=NULL)insert2(p);else{p->next=ready;ready=p;tail=p;}}//clrscr();system("CLS");printf(" output of round\n");printf("************************************************\n"); prt(alg); /*输出进程PCB信息*/run=ready; /*将就绪队列的第一个进程投入运行*/ready=ready->next;run->state='R';}/*优先数调度算法*/priority(char alg){while(run!=NULL) /*当运行队列不空时，有进程正在运行*/{run->cputime=run->cputime+1;run->needtime=run->needtime-1;run->prio=run->prio-3; /*每运行一次优先数降低3个单位*/if(run->needtime==0) /*如所需时间为0将其插入完成队列*/{run->next=finish;finish=run;run->state='F'; /*置状态为完成态*/run=NULL; /*运行队列头指针为空*/if(ready!=NULL) /*如就绪队列不空*/firstin(); /*将就绪对列的第一个进程投入运行*/}else /*没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列*/ if((ready!=NULL)&&(run->prio<ready->prio)){run->state='W';insert1(run);firstin(); /*将就绪队列的第一个进程投入运行*/}prt(alg); /*输出进程PCB信息*/}}/*时间片轮转法*/roundrun(char alg){while(run!=NULL){run->cputime=run->cputime+1;run->needtime=run->needtime-1;run->count=run->count+1;if(run->needtime==0)/*运行完将其变为完成态，插入完成队列*/{run->next=finish;finish=run;run->state='F';run=NULL;if(ready!=NULL)firstin(); /*就绪对列不空，将第一个进程投入运行*/}elseif(run->count==run->round) /*如果时间片到*/{run->count=0; /*计数器置0*/if(ready!=NULL) /*如就绪队列不空*/{run->state='W'; /*将进程插入到就绪队列中等待轮转*/ insert2(run);firstin(); /*将就绪对列的第一个进程投入运行*/}}prt(alg); /*输出进程信息*/}}/*主函数*/main(){char algo; /*算法标记*///clrscr();system("CLS");printf("type the algorithm:P/R(priority/roundrobin)\n"); scanf("%c",&algo); /*输入字符确定算法*/printf("Enter process number\n"); scanf("%d",&N); /*输入进程数*/if(algo=='P'||algo=='p'){create1(algo); /*优先数法*/priority(algo);}elseif(algo=='R'||algo=='r'){create2(algo); /*轮转法*/roundrun(algo);}}。

时间片轮转调度算法java代码

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验二带优先级的时间片轮换的进程调度算法的实现

计算机操作系统时间片循环轮转算法

操作系统实验报告——时间片调度轮转算法

时间片轮转调度算法java可视化模拟程序

时间片轮转调度算法设计与实现

操作系统实验(时间片轮转)

操作系统课程设计时间片轮转

操作系统实验：时间片轮转RR进程调度算法

RR时间片轮转算法（java）

Java实现进程调度算法（二）RR（时间片轮转）

操作系统之时间片轮转法实现代码

时间片轮转

java简单手写版本实现时间轮算法

实验一 时间片轮转进程调度算法

操作系统时间片轮转算法与优先级调度算法

时间片轮转调度算法java代码

实验一时间片轮转进程调度算法