时间片轮转调度
时间片轮转调度策略：在轮转(RR)法中，系统将所有的就绪进程按FCFS策略排成一个就绪队列。系统可设置每隔一定时间(如30 ms)便产生一次中断，去激活进程调度程序进行调度，把CPU分配给队首进程，并令其执行一个时间片。当它运行完毕后，又把处理机分配给就绪队列中新的队首进程，也让它执行一个时间片。这样，就可以保证就绪队列中的所有进程在确定的时间段内，都能获得一个时间片的处理机时间。
数据结构和符号说明
本次的PCB类数据结构有三个公共变量，五个私有变量，一个标志变量，以及一个时时返回给调度函数值的交互式变量。
//三个公共变量:作业名、到达时间、服务时间
String threadName; int timeArrival; int timeSever;
//五个私有变量：计算专用服务时间、开始执行时间、完成时间、周转时间、带权周转时间
private int timeSeverFor; private int timeStart; private int timeComplete;
private int timeTurnaround; private double timeWeightedTurnaround;
//一个标志：表示是否还需要调度 一个交互式变量：表示自己本次使用了多少时间
private boolean isFinish = false; private int timeUse;
另有setter、getter函数实现私有变量的访问，同时有一个public boolean isNotStart() { return timeStart == 0; }函数根据进程的开始时间是否为0判断本程序是否启动过。在计算完成时间时，通过timeSever进行判断。每次时间片执行时都会时timeSever减去相应时间，此处的timeSever是时时更新的剩余服务时间，如果在一个时间片内提前结束了，则完成时间以及本次进程使用的时间都会进行调整，具体实现是通过三元运算符实现timeSever -= timeSlice; timeComplete = timeSever > 0 ? timeNow + timeSlice : timeNow + timeSlice + timeSever; timeUse = timeSever >= 0 ? timeSlice : timeSlice + timeSever;，而也只有在剩余服务时间<=0时即本进程已完成才会进行周转时间等计算。
RR类进行系统调度时，由主机记录时间，并按照个一个轮转片内进程实际使用的时间累加，调用时只需按照到达时间排序一次就好，随后便是各时间片轮转，使用一个while (countFinish < num)表示只要有一个进程未完成都会继续执行循环，而在while循环内部刚好是一个for each循环，各进程按照顺序一一轮转，如果进程未完成，则会调度此进程，完成就countFinish加1。调度时如果是第一次启动还需赋启动时间初值，随后运行本轮次pcb.run(timeNow, timeSlice)，记录下这次实际使用的时间并累加到当前时间上。
测试类Test包含一个主函数用于启动并时间片长度q，以及一个专门用于接受输入进程信息的函数。并且输入的进程数组在测试类中定义，也能实现在RR类中的函数直接更改进程的信息。
流程图
源程序
PCB类
import java.text.DecimalFormat;
public class PCB {
/**
* 三个公共变量:作业名、到达时间、服务时间
*/
String threadName;
int timeArrival;
int timeSever;
/**
* 五个私有变量：计算专用服务时间、开始执行时间、完成时间、周转时间、带权周转时间
* 一个标志：表示是否还需要调度
* 一个交互式变量：表示自己本次使用了多少时间
*/
private int timeSeverFor;
private int timeStart;
private int timeComplete;
private int timeTurnaround;
private double timeWeightedTurnaround;
private boolean isFinish = false;
private int timeUse;
public PCB() {
//允许空参构造器存在
}
public PCB(String threadName, int timeArrival, int timeSever) {
//正规的有参构造器
this.threadName = threadName;
this.timeArrival = timeArrival;
this.timeSever = timeSever;
this.timeSeverFor = timeSever;
}
public void setTimeStart(int timeStart) {
//将由算法调度程序分配开始时间
this.timeStart = timeStart;
}
public boolean isNotStart() {
return timeStart == 0;
}
public int getTimeTurnaround() {
return timeTurnaround;
}
public double getTimeWeightedTurnaround() {
return timeWeightedTurnaround;
}
public boolean isFinish() {
return isFinish;
}
public int getTimeUse() {
return timeUse;
}
public void run(int timeNow, int timeSlice) {
//开始调度后的运行内容
/*计算完成时间*/
if (timeSever > 0) {
timeSever -= timeSlice;
// 此处保证进程在时间片内提前完成的情况下，依然能准确算出完成时间，并返回正确的使用时间
timeComplete = timeSever > 0 ? timeNow + timeSlice : timeNow + timeSlice + timeSever;
timeUse = timeSever >= 0 ? timeSlice : timeSlice + timeSever;
}
/* 当本次进程完成时，计算周转时间、带权周转时间 */
if (timeSever <= 0) {
isFinish = true;
timeTurnaround = timeComplete - timeArrival;
DecimalFormat dF = new DecimalFormat("0.00");
timeWeightedTurnaround = Double.parseDouble(dF.format((double) timeTurnaround / timeSeverFor));
//调用toString()将内容输出
System.out.println(this);
}
}
@Override
public String toString() {
return "'" + threadName + '\'' +
"\t\t" + timeArrival +
"\t\t" + timeSeverFor +
"\t\t\t" + timeStart +
"\t\t" + timeComplete +
"\t\t" + timeTurnaround +
"\t\t" + timeWeightedTurnaround;
}
}
RR类
public class RR {
public void dispatch(PCB[] pcbarr, int timeSlice) {
System.out.println("作业名\t到达时间\t服务时间\t开始执行时间\t完成时间\t周转时间\t带权周转时间");
int num = pcbarr.length;
//由主机记录当前时间，以便实现时间片轮转
int timeNow = 0;
sort(pcbarr, num);
//此后的PCB数组都是依照到达时间排序完成的
int countFinish = 0;
while (countFinish < num) {
countFinish = 0;
for (PCB pcb : pcbarr) {
//如果此进程未完成，且时间已到达，则会给该进程一个时间片,否则进行下一个
if (timeNow >= pcb.timeArrival) {
if ((!pcb.isFinish())) {
if (pcb.isNotStart()) {
pcb.setTimeStart(timeNow);
}
pcb.run(timeNow, timeSlice);
timeNow += pcb.getTimeUse();
} else {
countFinish++;
}
}else{
//若还未到，进行下一轮，没有需要调度的进程则直接当前时间加一
if(pcb.isFinish()){
timeNow++;
}
break;
}
}
}
//周转时间之和与带权周转时间之和
int timeTurnaroundSum = 0;
double timeWeightedTurnaroundSum = 0;
for (PCB pcb : pcbarr) {
timeTurnaroundSum += pcb.getTimeTurnaround();
timeWeightedTurnaroundSum += pcb.getTimeWeightedTurnaround();
}
System.out.println("平均周转时间：" + (double) timeTurnaroundSum / num +
"，平均带权周转时间：" + timeWeightedTurnaroundSum / num);
}
public void sort(PCB[] arr, int num) {
//根据到达时间对作业进行升序排序，排序方式：选择排序
for (int i = 0; i < num - 1; i++) {
int index = i;
for (int j = i + 1; j < num; j++) {
if (arr[j].timeArrival < arr[index].timeArrival) {
index = j;
}
}
//将找到的最小值放到第一的位置，进行下一遍循环
PCB temp = arr[index];
arr[index] = arr[i];
arr[i] = temp;
}
}
}
Test类
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
// 设置时间片长度
System.out.print("时间片轮转算法\n请设置时间片长度q = ");
Scanner sc = new Scanner(System.in);
int timeSlice = sc.nextInt();
// 读取输入的数组
PCB[] arr1 = dataReadIn();
//调用时间片轮转算法
RR rr = new RR();
rr.dispatch(arr1, timeSlice);
}
public static PCB[] dataReadIn() {
//数据读入函数,直接设为静态函数，强制要求写入数据
System.out.print("请输入本次需要调度的作业数目：");
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
PCB[] starr = new PCB[n];
System.out.println("请输入每一个作业的作业名、到达时间、服务时间（一行一个,中间用空格区分）");
for (int i = 0; i < n; i++) {
starr[i] = new PCB(sc.next(), sc.nextInt(), sc.nextInt());
}
return starr;
}
}
运行时的初值和结果
时间片轮转算法
请设置时间片长度q = 1
请输入本次需要调度的作业数目：5
请输入每一个作业的作业名、到达时间、服务时间（一行一个,中间用空格区分）
A 0 4
B 1 3
C 2 4
D 3 2
E 4 4
作业名 到达时间 服务时间 开始执行时间 完成时间 周转时间 带权周转时间
‘D’ 3 2 3 9 6 3.0
‘B’ 1 3 1 12 11 3.67
‘A’ 0 4 5 15 15 3.75
‘C’ 2 4 2 16 14 3.5
‘E’ 4 4 4 17 13 3.25
平均周转时间：11.8，平均带权周转时间：3.434时间片轮转算法
请设置时间片长度q = 4
请输入本次需要调度的作业数目：5
请输入每一个作业的作业名、到达时间、服务时间（一行一个,中间用空格区分）
A 0 4
B 1 3
C 2 4
D 3 2
E 4 4
作业名 到达时间 服务时间 开始执行时间 完成时间 周转时间 带权周转时间
‘A’ 0 4 0 4 4 1.0
‘B’ 1 3 4 7 6 2.0
‘C’ 2 4 7 11 9 2.25
‘D’ 3 2 11 13 10 5.0
‘E’ 4 4 13 17 13 3.25
平均周转时间：8.4，平均带权周转时间：2.7
与理想状态相同
