湖北师范大学操作系统实验：第二题：基于响应比的进程调度算法

Demo02

问题：

​ 要求输入3个进程的信息，按照最高响应比优先的[调度算法调度算法计算并输出每个进程的周转时间。(若两个进程的响应比相同，则优先选择先进入的进程。若两个进程的响应比相同，而且进入时刻也相同，则按照输入的顺序执行，如：P4和P6的响应比相同且进入时刻也相同，如P4先输入则选择P4先执行)

1. 程序简介：

​ 该程序模拟了一个基于响应比的进程调度算法。它会根据进程的到达时间和执行时间计算出每个进程的周转时间。

2. 使用方法：

• 输入格式：
  • 程序从标准输入读取多行数据，每行表示一个进程及其属性。
  • 每行由进程名称、到达时间和执行时间组成。
• 输出格式：
  • 程序会输出每个进程的周转时间，用空格分隔。

3. 如何运行：

1. 打开程序，并通过命令行或 IDE 运行 Java 程序。
2. 程序提示输入时，按照指定格式输入进程信息，并按 Enter 确认。
3. 程序会计算每个进程的周转时间。
4. 最终，程序会输出每个进程的周转时间。

4. 注意事项：

• 输入的进程信息应符合指定格式，包括进程名称、到达时间和执行时间。
• 程序会根据到达时间和执行时间计算周转时间，如果有进程未被选定执行，则输出结果可能会包含 0。

5. 运行示例：

以下是一组示例输入和输出：

Copy code输入：
P1 1 1
P2 2 2
P3 3 3

输出：
1 2 4

输入：
P1 1 4
P2 2 8
P3 3 1

输出：
4 12 3

6.代码实现：

/**
 * @author Allen
 * @version 1.0
in:
P1 1 1
P2 2 2
P3 3 3
out:
1 2 4

in:
P1 1 4
P2 2 8
P3 3 1

out:
4 12 3
 */
import java.util.*;

// 进程类，表示每个进程及其相关属性
class Process {
    String name;         // 进程名称
    int arrivalTime;     // 进程到达时间
    int runTime;         // 进程执行所需时间
    int waitingTime;     // 进程在队列中等待时间
    int finishTime;      // 进程完成执行时间

    // 构造函数，初始化进程对象
    Process(String name, int arrivalTime, int runTime) {
        this.name = name;
        this.arrivalTime = arrivalTime;
        this.runTime = runTime;
        this.waitingTime = 0;   // 初始等待时间为0
        this.finishTime = 0;    // 初始完成时间为0
    }
}

public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Process[] processes = new Process[3]; // 存储3个进程的数组

        // 输入每个进程的信息
        for (int i = 0; i < 3; i++) {
            String name = scanner.next();       // 输入进程名称
            int arrivalTime = scanner.nextInt(); // 输入到达时间
            int runTime = scanner.nextInt();     // 输入执行时间
            processes[i] = new Process(name, arrivalTime, runTime); // 创建进程对象
        }
        scanner.close();

        int currentTime = 0;    // 初始化当前时间
        int completed = 0;      // 计数器，跟踪完成执行的进程数量

        // 调度进程，直到所有进程都完成执行
        while (completed < processes.length) {
            double maxResponseRatio = -1; // 初始化最大响应比
            int selectedProcess = -1;     // 选定进程的索引

            // 计算当前时间下每个合适进程的响应比
            for (int i = 0; i < processes.length; i++) {
                if (processes[i].arrivalTime <= currentTime && processes[i].finishTime == 0) {
                    double responseRatio = (double) (currentTime - processes[i].arrivalTime + processes[i].runTime) / processes[i].runTime;

                    // 检查当前进程是否有更高的响应比
                    if (responseRatio > maxResponseRatio) {
                        maxResponseRatio = responseRatio; // 更新最大响应比
                        selectedProcess = i;             // 更新选定进程的索引
                    }
                }
            }

            // 执行选定的进程，或者如果没有选定进程则增加当前时间
            if (selectedProcess != -1) {
                Process current = processes[selectedProcess]; // 获取选定的进程
                currentTime += current.runTime;                // 更新当前时间
                current.finishTime = currentTime;              // 设置进程的完成时间
                completed++;                                   // 增加完成执行的进程数量
            } else {
                currentTime++; // 如果没有选定进程，则增加时间
            }
        }

        // 计算并输出每个进程的周转时间
        for (Process process : processes) {
            int turnaroundTime = process.finishTime - process.arrivalTime;
            System.out.print(turnaroundTime + " "); // 输出每个进程的周转时间
        }
    }
}

7.运行结果：