多级反馈队列调度算法Java

多级反馈队列调度算法是一种常见的CPU调度算法，可以实现更好的性能和响应时间。下面是一个简单的Java实现：

首先定义一个进程类，包含进程名、进程状态、进程优先级、进程需要的CPU时间片以及已经使用的CPU时间片等属性：

class Process {
    String name;
    int state;
    int priority;
    int needTime;
    int usedTime;

    public Process(String name, int priority, int needTime) {
        this.name = name;
        this.priority = priority;
        this.needTime = needTime;
        this.usedTime = 0;
        this.state = 0;
    }
}

然后定义一个多级反馈队列调度类，该类包含一个进程队列和多个队列，每个队列都有一个不同的优先级：

class MFQScheduler {
    Queue<Process> queue;
    Queue<Process>[] queues;
    int[] quantum;
    int time;

    public MFQScheduler(int[] quantum) {
        this.queue = new LinkedList<>();
        this.queues = new LinkedList[quantum.length];
        this.quantum = quantum;
        for (int i = 0; i < quantum.length; i++) {
            this.queues[i] = new LinkedList<>();
        }
        this.time = 0;
    }

    public void addProcess(Process process) {
        this.queue.offer(process);
    }

    public void run() {
        while (!this.queue.isEmpty() || !isEmpty()) {
            if (!this.queue.isEmpty()) {
                Process process = this.queue.poll();
                this.queues[0].offer(process);
            }

            for (int i = 0; i < quantum.length; i++) {
                if (!this.queues[i].isEmpty()) {
                    Process process = this.queues[i].poll();
                    int needTime = process.needTime - process.usedTime;
                    int sliceTime = Math.min(quantum[i], needTime);

                    // 模拟进程执行
                    process.state = 1;
                    process.usedTime += sliceTime;
                    if (process.usedTime == process.needTime) {
                        process.state = 2;
                    }

                    // 将剩余时间加入到下一个队列
                    if (i < quantum.length - 1 && sliceTime < needTime) {
                        process.priority++;
                        this.queues[i + 1].offer(process);
                    } else {
                        this.queue.offer(process);
                    }
                }
            }

            this.time++;
        }
    }

    public boolean isEmpty() {
        for (int i = 0; i < quantum.length; i++) {
            if (!this.queues[i].isEmpty()) {
                return false;
            }
        }
        return true;
    }
}

在主函数中，我们可以创建一个多级反馈队列调度器，并添加一些进程：

public static void main(String[] args) {
    int[] quantum = {1, 2, 4, 8};
    MFQScheduler scheduler = new MFQScheduler(quantum);

    Process p1 = new Process("p1", 0, 7);
    Process p2 = new Process("p2", 1, 12);
    Process p3 = new Process("p3", 2, 4);
    Process p4 = new Process("p4", 3, 2);
    Process p5 = new Process("p5", 0, 5);

    scheduler.addProcess(p1);
    scheduler.addProcess(p2);
    scheduler.addProcess(p3);
    scheduler.addProcess(p4);
    scheduler.addProcess(p5);

    scheduler.run();
}

运行后，可以看到每个进程的执行情况以及总共的执行时间。