private List<Process> processList;是什么意思

这是一个定义在某个类中的私有成员变量，表示进程列表的数据结构。其中List是一个可以动态增长的数组，Process代表一个进程。private关键字表示该成员变量只能在该类的内部被访问和修改，外部的其他类无法直接访问该变量。这样做可以保证该变量的安全性和封装性。该列表可以用于存储所有的进程，包括就绪进程、阻塞进程和完成进程等。

相关问题

用java语言编写和调试一个进程调度程序，实现基于优先权的进程调度算法和基于时间片轮转调度算法。

实现基于优先权的进程调度算法：

import java.util.*;

class Process {
    public int pid; // 进程ID
    public int priority; // 优先级
    public int burstTime; // 运行时间

    public Process(int pid, int priority, int burstTime) {
        this.pid = pid;
        this.priority = priority;
        this.burstTime = burstTime;
    }

    public void run() {
        System.out.println("Process " + pid + " is running.");
        try {
            Thread.sleep(burstTime); // 模拟运行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Process " + pid + " is finished.");
    }
}

class PriorityScheduler {
    private List<Process> processList;

    public PriorityScheduler(List<Process> processList) {
        this.processList = processList;
        // 按照优先级从大到小排序
        Collections.sort(processList, new Comparator<Process>() {
            @Override
            public int compare(Process p1, Process p2) {
                return p2.priority - p1.priority;
            }
        });
    }

    public void run() {
        for (Process process : processList) {
            process.run();
        }
    }
}

public class PrioritySchedulerDemo {
    public static void main(String[] args) {
        List<Process> processList = new ArrayList<>();
        processList.add(new Process(1, 3, 1000));
        processList.add(new Process(2, 1, 2000));
        processList.add(new Process(3, 2, 1500));
        PriorityScheduler scheduler = new PriorityScheduler(processList);
        scheduler.run();
    }
}

实现基于时间片轮转调度算法：

import java.util.*;

class Process {
    public int pid; // 进程ID
    public int burstTime; // 运行时间

    public Process(int pid, int burstTime) {
        this.pid = pid;
        this.burstTime = burstTime;
    }

    public void run(int timeSlice) {
        System.out.println("Process " + pid + " is running.");
        try {
            Thread.sleep(timeSlice); // 模拟运行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Process " + pid + " is finished.");
    }
}

class RoundRobinScheduler {
    private List<Process> processList;

    public RoundRobinScheduler(List<Process> processList) {
        this.processList = processList;
    }

    public void run(int timeSlice) {
        Queue<Process> queue = new LinkedList<>(processList);
        while (!queue.isEmpty()) {
            Process process = queue.poll();
            process.run(timeSlice);
            if (process.burstTime > timeSlice) {
                process.burstTime -= timeSlice;
                queue.offer(process); // 将剩余时间重新加入队列
            }
        }
    }
}

public class RoundRobinSchedulerDemo {
    public static void main(String[] args) {
        List<Process> processList = new ArrayList<>();
        processList.add(new Process(1, 2000));
        processList.add(new Process(2, 1500));
        processList.add(new Process(3, 1000));
        RoundRobinScheduler scheduler = new RoundRobinScheduler(processList);
        scheduler.run(500);
    }
}

Android stduio用布局方法实现姓名、年龄、身高

由于本题中涉及多个算法的实现，因此我们需要先定义一个进程类，用于存储进程的相关信息：

public class Process {
    private String name; // 进程名称
    private int createTime; // 进程创建时间
    private int executeTime; // 进程执行时间
    private int startTime; // 进程开始执行的时间
    private int finishTime; // 进程完成执行的时间
    private int turnaroundTime; // 进程周转时间
    private double weightedTurnaroundTime; // 进程带权周转时间

    public Process(String name, int createTime, int executeTime) {
        this.name = name;
        this.createTime = createTime;
        this.executeTime = executeTime;
    }

    // 省略getter和setter方法
}

接下来，我们可以先手动创建几个进程，方便测试各种算法的实现：

public class Main {
    public static void main(String[] args) {
        List<Process> processList = new ArrayList<>();
        processList.add(new Process("P1", 0, 3));
        processList.add(new Process("P2", 2, 6));
        processList.add(new Process("P3", 4, 4));
        processList.add(new Process("P4", 6, 2));
    }
}

当然，我们也可以编写一个方法随机生成几个进程：

public static List<Process> generateProcesses(int num) {
    List<Process> processList = new ArrayList<>();
    Random random = new Random();
    for (int i = 1; i <= num; i++) {
        processList.add(new Process("P" + i, random.nextInt(10), random.nextInt(10) + 1));
    }
    return processList;
}

接下来，我们可以依次实现各种调度算法的实现。

1. 先来实现先来先服务（FCFS）算法：

public static void fcfs(List<Process> processList) {
    int currentTime = 0;
    for (Process process : processList) {
        if (process.getCreateTime() > currentTime) {
            currentTime = process.getCreateTime();
        }
        process.setStartTime(currentTime);
        process.setFinishTime(currentTime + process.getExecuteTime());
        process.setTurnaroundTime(process.getFinishTime() - process.getCreateTime());
        process.setWeightedTurnaroundTime((double) process.getTurnaroundTime() / process.getExecuteTime());
        currentTime = process.getFinishTime();
    }
}

2. 其次是最短作业优先（SJF）算法：

public static void sjf(List<Process> processList) {
    List<Process> sortedList = new ArrayList<>(processList);
    sortedList.sort(Comparator.comparing(Process::getExecuteTime));
    fcfs(sortedList);
}

3. 再然后是优先级调度算法：

public static void priority(List<Process> processList) {
    List<Process> sortedList = new ArrayList<>(processList);
    sortedList.sort(Comparator.comparing(Process::getCreateTime));
    int currentTime = 0;
    while (!sortedList.isEmpty()) {
        int minPriority = Integer.MAX_VALUE;
        Process minProcess = null;
        for (Process process : sortedList) {
            if (process.getCreateTime() <= currentTime && process.getExecuteTime() > 0 && process.getExecuteTime() < minPriority) {
                minPriority = process.getExecuteTime();
                minProcess = process;
            }
        }
        if (minProcess == null) {
            currentTime++;
        } else {
            minProcess.setStartTime(currentTime);
            minProcess.setFinishTime(currentTime + minProcess.getExecuteTime());
            minProcess.setTurnaroundTime(minProcess.getFinishTime() - minProcess.getCreateTime());
            minProcess.setWeightedTurnaroundTime((double) minProcess.getTurnaroundTime() / minProcess.getExecuteTime());
            currentTime = minProcess.getFinishTime();
            sortedList.remove(minProcess);
        }
    }
}

4. 最高响应比优先（HRRN）算法：

public static void hrrn(List<Process> processList) {
    List<Process> sortedList = new ArrayList<>(processList);
    sortedList.sort(Comparator.comparing(Process::getCreateTime));
    int currentTime = 0;
    while (!sortedList.isEmpty()) {
        double maxRatio = Double.MIN_VALUE;
        Process maxProcess = null;
        for (Process process : sortedList) {
            if (process.getCreateTime() <= currentTime && process.getExecuteTime() > 0) {
                double ratio = (currentTime - process.getCreateTime() + process.getExecuteTime()) / (double) process.getExecuteTime();
                if (ratio > maxRatio) {
                    maxRatio = ratio;
                    maxProcess = process;
                }
            }
        }
        if (maxProcess == null) {
            currentTime++;
        } else {
            maxProcess.setStartTime(currentTime);
            maxProcess.setFinishTime(currentTime + maxProcess.getExecuteTime());
            maxProcess.setTurnaroundTime(maxProcess.getFinishTime() - maxProcess.getCreateTime());
            maxProcess.setWeightedTurnaroundTime((double) maxProcess.getTurnaroundTime() / maxProcess.getExecuteTime());
            currentTime = maxProcess.getFinishTime();
            sortedList.remove(maxProcess);
        }
    }
}

最后，我们可以在main方法中调用各种算法并输出结果：

public static void main(String[] args) {
    List<Process> processList = generateProcesses(4);

    System.out.println("FCFS:");
    fcfs(processList);
    printResult(processList);

    System.out.println("SJF:");
    sjf(processList);
    printResult(processList);

    System.out.println("Priority:");
    priority(processList);
    printResult(processList);

    System.out.println("HRRN:");
    hrrn(processList);
    printResult(processList);
}

public static void printResult(List<Process> processList) {
    int totalTurnaroundTime = 0;
    double totalWeightedTurnaroundTime = 0;
    for (Process process : processList) {
        totalTurnaroundTime += process.getTurnaroundTime();
        totalWeightedTurnaroundTime += process.getWeightedTurnaroundTime();
        System.out.println(process);
    }
    System.out.println("Total turnaround time: " + totalTurnaroundTime);
    System.out.println("Average turnaround time: " + (double) totalTurnaroundTime / processList.size());
    System.out.println("Average weighted turnaround time: " + totalWeightedTurnaroundTime / processList.size());
}

完整代码如下：