多级反馈队列调度算法的调度机制可描述如下：
1).设置多个就绪队列。
(2) 每个队列都采用FCFS算法。当新进程进入内存后，首先将它放入第一队列的末尾，按FCFS原则等待调度。当轮到该进程执行时，如它能在该时间片内完成，便可撤离系统。否则，即它在一个时间片结束时尚未完成，调度程序将其转入第二队列的末尾等待调度；如果它在第二队列中运行一个时间片后仍未完成，再依次将它放入第三队列，......，依此类推。当进程最后被降到第n队列后，在第n队列中便采取按RR方式运行。
(3) 按队列优先级调度。调度程序首先调度最高优先级队列中的诸进程运行，仅当第一队列空闲时才调度第二队列中的进程运行；换言之，仅当第1～(i-1)所有队列均空时，才会调度第i队列中的进程运行。如果处理机正在第i队列中为某进程服务时又有新进程进入任一优先级较高的队列，此时须立即把正在运行的进程放回到第i队列的末尾，而把处理机分配给新到的高优先级进程。
代码:
import java.util.LinkedList;
import java.util.Scanner;
public class MultiLevelFeedbackQueueScheduler1 {
static final int time_slice = 1; // 第一队列时间片长度（分钟）
static final int N = 4; // 进程数
static class PCB {
String process_name; // 进程名字
int arrive_time; // 到达时间（分钟）
int service_time; // 需要服务时间（分钟）
int remain_time; // 还差多少时间（分钟）
int complete_time; // 完成时间（分钟）
char state; // 进程状态
public PCB(String process_name, int arrive_time, int service_time) {
this.process_name = process_name;
this.arrive_time = arrive_time;
this.service_time = service_time;
this.remain_time = service_time;
this.complete_time = 0;
this.state = 'w';
}
}
static LinkedList<PCB> Coming_queue = new LinkedList<>(); // 未到达队列
static LinkedList<PCB> Finish_queue = new LinkedList<>(); // 已完成队列
static LinkedList<PCB>[] Wait_queue; // 反馈队列
static int[] Queue_time_slice; // 各反馈队列的时间片（分钟）
static int Queue_Num; // 反馈队列数量
public static void sort(LinkedList<PCB> list) {
list.sort((p1, p2) -> Integer.compare(p1.arrive_time, p2.arrive_time));//按照到达的时间进行排序
}
public static void init_wait_queue(int queue_num) {
Queue_time_slice = new int[queue_num];
Wait_queue = (LinkedList<PCB>[]) new LinkedList<?>[queue_num]; // 泛型数组初始化
for (int i = 0; i < queue_num; i++) {
Queue_time_slice[i] = (int) (time_slice * Math.pow(2, i));
Wait_queue[i] = new LinkedList<>();
}
}
public static int input() {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入反馈队列级数: ");
Queue_Num = scanner.nextInt();
LinkedList<PCB> pcbList = new LinkedList<>();
for (int i = 0; i < N; i++) {
System.out.println("------\n请输入第" + (i + 1) + "进程名字: ");
String name = scanner.next();
System.out.print("请输入到达时间 (格式 HH:mm): ");
String timeStr = scanner.next();
String[] timeParts = timeStr.split(":");//按照:进行分割
int hours = Integer.parseInt(timeParts[0]);//integer.parseint()是将整型数据Integer转换为基本数据类型int
int minutes = Integer.parseInt(timeParts[1]);
int arriveTime = hours * 60 + minutes; // 转换为分钟
System.out.print("请输入服务时间 (分钟): ");
int serviceTime = scanner.nextInt();
pcbList.add(new PCB(name, arriveTime, serviceTime));
}
sort(pcbList);
for (PCB pcb : pcbList) {
Coming_queue.add(pcb);
}
init_wait_queue(Queue_Num);
return 0;
}
public static boolean accept_process(int current_time) {
while (!Coming_queue.isEmpty() && Coming_queue.peek().arrive_time <= current_time) {
Wait_queue[0].add(Coming_queue.poll());
return true;
}
return false;
}
public static void run() {
boolean over = false;
int current_time = Coming_queue.peek().arrive_time; // 系统当前时间（分钟）
PCB temp = null; // 存放要执行进程的pcb
int t = 0; // 存放时间片（分钟）
int queue_serial = 0; // 要执行进程所在队列号,从0~Queue_Num-1
int count = 1; // 调度次数
while (true) {
over = true;
accept_process(current_time); // 接收当前时间到达的进程
for (int i = 0; i < Queue_Num; i++) {
if (!Wait_queue[i].isEmpty()) {
over = false;
temp = Wait_queue[i].poll();
t = Queue_time_slice[i];
queue_serial = i;
break;
}
}
if (!Coming_queue.isEmpty()) {
over = false;
}
if (over) {
break;
}
System.out.println("\n第" + count + "次调度进程: " + temp.process_name + " 时间 : " + formatTime(current_time));
while (true) {
t--;
current_time++;
temp.state = 'r';
temp.remain_time--;
if (temp.remain_time == 0) { // 进程执行完
temp.state = 'f';
temp.complete_time = current_time;
Finish_queue.add(temp);
break;
} else if (t == 0) { // 进程还没执行完但是时间片用完
temp.state = 'w';
if (queue_serial == Queue_Num - 1) {
Wait_queue[queue_serial].add(temp); // 插入最后一级队尾
} else {
Wait_queue[queue_serial + 1].add(temp); // 插入下一级反馈队列
}
break;
} else if (queue_serial != 0 && accept_process(current_time)) { // 进程还没执行完，时间片还没用完，可以被抢占
temp.state = 'w';
Wait_queue[queue_serial].add(temp); // 插入本级反馈队列
break;
}
}
count++;
}
}
public static void print() {
float[] round_time = new float[N]; // 周转时间
float[] force_round_time = new float[N]; // 带权周转时间
float sum = 0; // 存放各进程的带权周转时间和
System.out.println("\n 进程 |" + "到达时间 |" + " 服务时间 |" + " 完成时间 |" + " 周转时间 |" + " 带权周转时间");
int i = 0;
while (!Finish_queue.isEmpty()) {
PCB pcb = Finish_queue.poll();
round_time[i] = pcb.complete_time - pcb.arrive_time;
force_round_time[i] = round_time[i] / pcb.service_time;
System.out.printf("%s\t| %s\t | %d \t | %s\t | %.2f\t | %.2f\n",
pcb.process_name, formatTime(pcb.arrive_time), pcb.service_time, formatTime(pcb.complete_time),
round_time[i], force_round_time[i]);
sum += force_round_time[i];
i++;
}
System.out.printf("\n\n系统平均带权周转时间: %.2f\n", sum / i);
}
public static String formatTime(int minutes) {
int hours = minutes / 60;
int mins = minutes % 60;
return String.format("%02d:%02d", hours, mins);
}
public static void main(String[] args) {
System.out.println("\t\t多级反馈队列调度算法");
input();
run();
print();
}
}运行结果:
