【进程调度算法】时间片轮转调度算法、多级反馈队列调度算法（Java实现）

时间片轮转调度算法（RR）是十分简单的进程调度算法。

进程在执行时的情况

• 在该时间片内进程执行完毕，这种情况调度程序将立即把该进程弹出队列，并把CPU分配给新的队首进程
• 在该时间片内进程未执行完毕，调度程序将立即中断该进程执行，把该进程加入队尾，并将CPU分配给新的队首进程
• 该时间片未结束时有一个新的进程到达，就把新进程放到队尾，并继续执行该时间片（自己的理解，不一定对~）

第3种情况，在实现时的简单做法就是：

直接把运行时间加到该时间片结束或进程执行完毕，接着while循环把所有时间已到达的进程从processes（维护还未到达的那些进程）队首拿出来，放进就绪队列，然后把刚刚处理的进程放进就绪队列。

多级反馈队列（Multilevel Feedback Queue）调度算法是「时间片轮转调度算法」和「最高优先级算法」的综合和发展。

• 「多级」表示有多个队列，每个队列优先级从高到低，同时优先级越高时间片越短。
• 「反馈」表示如果有新的进程加入优先级高的队列时，立刻停止当前正在运行的进程，转而去运行优先级高的队列；

来看看，它是如何工作的：

• 设置了多个队列，赋予每个队列不同的优先级，每个队列优先级从高到低，同时优先级越高时间片越短；
• 新的进程会被放入到第一级队列（即时间片最短的队列）的末尾，按先来先服务的原则排队等待被调度，如果在第一级队列规定的时间片没运行完成，则将其转入到第二级队列的末尾，以此类推，直至完成；
• 当较高优先级的队列为空，才调度较低优先级的队列中的进程运行（这让你想起了什么？我想起了：前端的“事件循环机制”的同步任务队列、微任务队列和宏任务队列，它们也是这样的关系）。如果进程运行时，有新进程进入较高优先级的队列，则停止当前运行的进程并将其移入到原队列末尾，接着让较高优先级的进程运行；

可以发现，对于短作业可能可以在第一级队列很快被处理完。对于长作业，如果在第一级队列处理不完，可以移入下次队列等待被执行，虽然等待的时间变长了，但是运行时间也会更长了，所以该算法很好的兼顾了长短作业，同时有较好的响应时间。

实现上的一些注意点：

• 多级反馈队列调度算法在最低优先级队列里，虽然是类似RR的反复轮转，但实际上没法复用RR的代码。
• 参考2的代码（python实现）是有问题的，主要问题是：当有一个新进程到来（加入最高优先级队列），即使时间片没用完且进程没执行完，也应该立刻停止当前时间片，转而去处理新进程（就是要体现上文的「反馈」）。因此，当前进程的拿到时间片后能运行的时间为：min(时间片长度，当前进程还需要运行的时间，离一个新进程到来还有多久)。

有关计算

• 周转时间 = 进程完成时间 - 进程到达时间
• 带权周转时间 = 进程周转时间 / 进程实际运行时间（或者说“服务时间”）
• 平均周转时间 = （进程1周转时间 + … + 进程n周转时间）/ n
• 平均带权周转时间 = （进程1带权周转时间 + … + 进程n带权周转时间）/ n

本文用Java实现了时间片轮转调度算法和多级反馈队列调度算法，完整代码有点长，真的很后悔用Java来写，用js写会轻松一些的！

代码

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;

class Proc {
    String name;
    int arriveTime, serveTime, needTime, cyclingTime;
    double wCyclingTime;

    Proc(String name, int arriveTime, int serveTime) {
        this.name = name;
        this.arriveTime = arriveTime;
        this.serveTime = serveTime;
        this.needTime = serveTime;
    }

    void showFinishInfo(int finishTime) {
        cyclingTime = finishTime - arriveTime;
        wCyclingTime = 1.0 * cyclingTime / serveTime;
        System.out.printf("进程%s任务已完成，完成时间：%d，轮转时间：%d，带权轮转时间：%.6f\n",
            name, finishTime, cyclingTime, wCyclingTime);
    }

    @Override
    public String toString() {
        return "(" + name + "," + needTime + ")";
    }
}

class MyQueue {
    Queue<Proc> q;
    int timeSlot;

    MyQueue(Queue<Proc> q, int time) {
        this.q = q;
        this.timeSlot = time;
    }

    void showInfo(int curRuntime) {
        StringBuilder sb = new StringBuilder();
        for (Proc p : q) sb.append(p);
        System.out.printf("当前时刻：%d，队列（时间片：%d）元素：%s\n",
            curRuntime, timeSlot, sb.toString());
    }

    static void showInfo(MyQueue[] queues, int curRuntime) {
        for (MyQueue q : queues) q.showInfo(curRuntime);
    }
}

public class MulitlevedFeedback {
    private static int curRuntime = 0;
    private static int totCyclingTime = 0;
    private static double totWCyclingTime = 0;

    private static boolean processRunning(Proc curP, int timeSlot) {
        if (curP.needTime <= timeSlot) {
            curRuntime += curP.needTime;
            curP.showFinishInfo(curRuntime);
            totCyclingTime += curP.cyclingTime;
            totWCyclingTime += curP.wCyclingTime;
            return true;
        }
        curRuntime += timeSlot;
        curP.needTime -= timeSlot;
        return false;
    }

    private static void addComingProcess(MyQueue q, Queue<Proc> processes) {
        while (!processes.isEmpty() && curRuntime >= processes.peek().arriveTime)
            q.q.add(processes.poll());
    }

    // 约定：同一时刻，先加入后续进程再加入刚刚处理的进程
    private static void _rr(MyQueue q, Queue<Proc> processes) {
        int timeSlot = q.timeSlot;
        final int processNum = processes.size();
        while (true) {
            addComingProcess(q, processes);
            if (q.q.isEmpty()) break;
            Proc curP = q.q.poll();
            boolean finished = processRunning(curP, timeSlot);
            addComingProcess(q, processes);
            if (!finished) q.q.add(curP);
            q.showInfo(curRuntime);
        }
        System.out.printf("平均轮转时间：%.6f，平均带权轮转时间：%.6f\n",
            1.0 * totCyclingTime / processNum, 1.0 * totWCyclingTime / processNum);
    }

    private static void _mulitlevedFeedback(MyQueue[] queues, Queue<Proc> processes) {
        addComingProcess(queues[0], processes);
        final int processNum = processes.size();
        while (true) {
            int idx = 0;
            for (; idx < queues.length; ++idx) if (!queues[idx].q.isEmpty()) break;
            if (idx == queues.length) break;
            Proc curP = queues[idx].q.poll();
            int timeSlot = queues[idx].timeSlot;
            int runTime = Math.min(timeSlot, Math.min(curP.needTime,
                processes.isEmpty() ? Integer.MAX_VALUE :
                    processes.peek().arriveTime - curRuntime));
            curP.needTime -= runTime;
            curRuntime += runTime;
            addComingProcess(queues[0], processes);
            if (curP.needTime > 0)
                queues[idx < queues.length - 1 ? idx + 1 : idx].q.add(curP);
            else {
                curP.showFinishInfo(curRuntime);
                totCyclingTime += curP.cyclingTime;
                totWCyclingTime += curP.wCyclingTime;
            }
            MyQueue.showInfo(queues, curRuntime);
        }
        System.out.printf("平均轮转时间：%.6f，平均带权轮转时间：%.6f\n",
            1.0 * totCyclingTime / processNum, 1.0 * totWCyclingTime / processNum);
    }

    public static void rr(MyQueue q, Queue<Proc> processes) {
        curRuntime = totCyclingTime = 0;
        totWCyclingTime = 0;
        _rr(q, processes);
    }

    public static void mulitlevedFeedback(MyQueue[] queues, Queue<Proc> processes) {
        curRuntime = totCyclingTime = 0;
        totWCyclingTime = 0;
        _mulitlevedFeedback(queues, processes);
    }

    public static void testRR() {
        System.out.println("测试时间片轮转调度算法：");
        MyQueue q = new MyQueue(new LinkedList<>(), 4);
        Proc[] processes = {
            new Proc("A", 0, 4),
            new Proc("B", 1, 3),
            new Proc("C", 2, 5),
            new Proc("D", 3, 2),
            new Proc("E", 4, 4)
        };
        rr(q, new LinkedList<>(Arrays.asList(processes)));
    }

    public static void testMF() {
        System.out.println("测试多级反馈队列调度算法：");
        MyQueue[] queues = {
            new MyQueue(new LinkedList<>(), 1),
            new MyQueue(new LinkedList<>(), 2),
            new MyQueue(new LinkedList<>(), 4)
        };
        Proc[] processes = {
            new Proc("A", 0, 4),
            new Proc("B", 1, 3),
            new Proc("C", 6, 4),
            new Proc("D", 9, 2),
            new Proc("E", 10, 4),
            new Proc("F", 13, 8)
        };
        mulitlevedFeedback(queues, new LinkedList<>(Arrays.asList(processes)));
    }

    public static void main(String[] args) {
        testMF();
        testRR();
    }
}

输出

时间片轮转调度算法

时间片为1时

测试时间片轮转调度算法：
当前时刻：1，队列（时间片：1）元素：BA
当前时刻：2，队列（时间片：1）元素：ACB
当前时刻：3，队列（时间片：1）元素：CBDA
当前时刻：4，队列（时间片：1）元素：BDAEC
当前时刻：5，队列（时间片：1）元素：DAECB
当前时刻：6，队列（时间片：1）元素：AECBD
当前时刻：7，队列（时间片：1）元素：ECBDA
当前时刻：8，队列（时间片：1）元素：CBDAE
当前时刻：9，队列（时间片：1）元素：BDAEC
进程B任务已完成，完成时间：10，轮转时间：9，带权轮转时间：3.000000
当前时刻：10，队列（时间片：1）元素：DAEC
进程D任务已完成，完成时间：11，轮转时间：8，带权轮转时间：4.000000
当前时刻：11，队列（时间片：1）元素：AEC
进程A任务已完成，完成时间：12，轮转时间：12，带权轮转时间：3.000000
当前时刻：12，队列（时间片：1）元素：EC
当前时刻：13，队列（时间片：1）元素：CE
当前时刻：14，队列（时间片：1）元素：EC
当前时刻：15，队列（时间片：1）元素：CE
当前时刻：16，队列（时间片：1）元素：EC
进程E任务已完成，完成时间：17，轮转时间：13，带权轮转时间：3.250000
当前时刻：17，队列（时间片：1）元素：C
进程C任务已完成，完成时间：18，轮转时间：16，带权轮转时间：3.200000
当前时刻：18，队列（时间片：1）元素：
平均轮转时间：11.600000，平均带权轮转时间：3.290000

时间片为4时

测试时间片轮转调度算法：
进程A任务已完成，完成时间：4，轮转时间：4，带权轮转时间：1.000000
当前时刻：4，队列（时间片：4）元素：BCDE
进程B任务已完成，完成时间：7，轮转时间：6，带权轮转时间：2.000000
当前时刻：7，队列（时间片：4）元素：CDE
当前时刻：11，队列（时间片：4）元素：DEC
进程D任务已完成，完成时间：13，轮转时间：10，带权轮转时间：5.000000
当前时刻：13，队列（时间片：4）元素：EC
进程E任务已完成，完成时间：17，轮转时间：13，带权轮转时间：3.250000
当前时刻：17，队列（时间片：4）元素：C
进程C任务已完成，完成时间：18，轮转时间：16，带权轮转时间：3.200000
当前时刻：18，队列（时间片：4）元素：
平均轮转时间：9.800000，平均带权轮转时间：2.890000

多级反馈队列调度算法

测试数据的设计，使得在13时刻进程E（在时间片为2的那个队列）的执行被进程F的加入打断，从而进程E只执行了1个单位的时间。

测试数据

new Proc("A", 0, 4),
new Proc("B", 1, 3),
new Proc("C", 6, 4),
new Proc("D", 9, 2),
new Proc("E", 10, 4),
new Proc("F", 13, 8)

输出

测试多级反馈队列调度算法：
当前时刻：1，队列（时间片：1）元素：(B,3)
当前时刻：1，队列（时间片：2）元素：(A,3)
当前时刻：1，队列（时间片：4）元素：
当前时刻：2，队列（时间片：1）元素：
当前时刻：2，队列（时间片：2）元素：(A,3)(B,2)
当前时刻：2，队列（时间片：4）元素：
当前时刻：4，队列（时间片：1）元素：
当前时刻：4，队列（时间片：2）元素：(B,2)
当前时刻：4，队列（时间片：4）元素：(A,1)
进程B任务已完成，完成时间：6，轮转时间：5，带权轮转时间：1.666667
当前时刻：6，队列（时间片：1）元素：(C,4)
当前时刻：6，队列（时间片：2）元素：
当前时刻：6，队列（时间片：4）元素：(A,1)
当前时刻：7，队列（时间片：1）元素：
当前时刻：7，队列（时间片：2）元素：(C,3)
当前时刻：7，队列（时间片：4）元素：(A,1)
当前时刻：9，队列（时间片：1）元素：(D,2)
当前时刻：9，队列（时间片：2）元素：
当前时刻：9，队列（时间片：4）元素：(A,1)(C,1)
当前时刻：10，队列（时间片：1）元素：(E,4)
当前时刻：10，队列（时间片：2）元素：(D,1)
当前时刻：10，队列（时间片：4）元素：(A,1)(C,1)
当前时刻：11，队列（时间片：1）元素：
当前时刻：11，队列（时间片：2）元素：(D,1)(E,3)
当前时刻：11，队列（时间片：4）元素：(A,1)(C,1)
进程D任务已完成，完成时间：12，轮转时间：3，带权轮转时间：1.500000
当前时刻：12，队列（时间片：1）元素：
当前时刻：12，队列（时间片：2）元素：(E,3)
当前时刻：12，队列（时间片：4）元素：(A,1)(C,1)
当前时刻：13，队列（时间片：1）元素：(F,8)
当前时刻：13，队列（时间片：2）元素：
当前时刻：13，队列（时间片：4）元素：(A,1)(C,1)(E,2)
当前时刻：14，队列（时间片：1）元素：
当前时刻：14，队列（时间片：2）元素：(F,7)
当前时刻：14，队列（时间片：4）元素：(A,1)(C,1)(E,2)
当前时刻：16，队列（时间片：1）元素：
当前时刻：16，队列（时间片：2）元素：
当前时刻：16，队列（时间片：4）元素：(A,1)(C,1)(E,2)(F,5)
进程A任务已完成，完成时间：17，轮转时间：17，带权轮转时间：4.250000
当前时刻：17，队列（时间片：1）元素：
当前时刻：17，队列（时间片：2）元素：
当前时刻：17，队列（时间片：4）元素：(C,1)(E,2)(F,5)
进程C任务已完成，完成时间：18，轮转时间：12，带权轮转时间：3.000000
当前时刻：18，队列（时间片：1）元素：
当前时刻：18，队列（时间片：2）元素：
当前时刻：18，队列（时间片：4）元素：(E,2)(F,5)
进程E任务已完成，完成时间：20，轮转时间：10，带权轮转时间：2.500000
当前时刻：20，队列（时间片：1）元素：
当前时刻：20，队列（时间片：2）元素：
当前时刻：20，队列（时间片：4）元素：(F,5)
当前时刻：24，队列（时间片：1）元素：
当前时刻：24，队列（时间片：2）元素：
当前时刻：24，队列（时间片：4）元素：(F,1)
进程F任务已完成，完成时间：25，轮转时间：12，带权轮转时间：1.500000
当前时刻：25，队列（时间片：1）元素：
当前时刻：25，队列（时间片：2）元素：
当前时刻：25，队列（时间片：4）元素：
平均轮转时间：11.800000，平均带权轮转时间：2.883333

参考：

https://juejin.cn/post/6869951514706722829

这个链接的实现代码是有误的：https://juejin.cn/post/6844903593527476232

时间片轮转调度算法的测试数据参考：https://juejin.cn/post/6844903523411296264