用java语言编写和调试一个进程调度程序,实现基于优先权的进程调度算法和基于时间片轮转调度算法。
时间: 2024-05-10 21:18:07 浏览: 9
实现基于优先权的进程调度算法:
```
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);
}
}
```