用java实现先来先服务算法、短作业优先算法、时间片轮转算法、优先级算法,并可以在键盘上输入1、2、3等控制选择这些算法。并将他们整合到一起
时间: 2023-12-01 16:10:19 浏览: 27
好的,我会尽力回答你的问题。在这里提供一个基本的实现方案,仅供参考。
首先,我们需要定义一个进程类,包含进程 id、到达时间、运行时间等属性:
```java
class Process {
int id; // 进程 id
int arriveTime; // 到达时间
int runTime; // 运行时间
public Process(int id, int arriveTime, int runTime) {
this.id = id;
this.arriveTime = arriveTime;
this.runTime = runTime;
}
}
```
接下来,我们可以分别实现四种调度算法。以先来先服务算法为例:
```java
import java.util.*;
public class FCFS {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(); // 进程数
List<Process> processes = new ArrayList<>();
for (int i = 0; i < n; i++) {
int id = sc.nextInt();
int arriveTime = sc.nextInt();
int runTime = sc.nextInt();
processes.add(new Process(id, arriveTime, runTime));
}
Collections.sort(processes, (p1, p2) -> p1.arriveTime - p2.arriveTime); // 按到达时间排序
int curTime = 0;
double totalTurnaroundTime = 0; // 总周转时间
for (Process process : processes) {
curTime = Math.max(curTime, process.arriveTime); // 等待进程到达
totalTurnaroundTime += curTime + process.runTime - process.arriveTime; // 更新总周转时间
curTime += process.runTime; // 运行进程
}
System.out.println("平均周转时间:" + totalTurnaroundTime / n);
}
}
```
其他算法的实现可以参考以下代码:
短作业优先算法:
```java
public class SJF {
public static void main(String[] args) {
// 与 FCFS 类似,只不过需要按运行时间排序
Collections.sort(processes, (p1, p2) -> p1.runTime - p2.runTime);
// ...
}
}
```
时间片轮转算法:
```java
public class RR {
public static void main(String[] args) {
int quantum = 2; // 时间片长度
Queue<Process> queue = new LinkedList<>(); // 就绪队列
int curTime = 0;
double totalTurnaroundTime = 0;
int finished = 0; // 已完成的进程数
while (finished < n) {
// 将到达时间小于等于当前时间的进程加入就绪队列
while (!processes.isEmpty() && processes.get(0).arriveTime <= curTime) {
queue.offer(processes.remove(0));
}
// 取出队首进程运行 quantum 时间
if (!queue.isEmpty()) {
Process process = queue.poll();
int runTime = Math.min(quantum, process.runTime);
curTime += runTime;
process.runTime -= runTime;
if (process.runTime == 0) {
totalTurnaroundTime += curTime - process.arriveTime;
finished++;
} else {
queue.offer(process);
}
} else {
curTime++;
}
}
System.out.println("平均周转时间:" + totalTurnaroundTime / n);
}
}
```
优先级算法:
```java
public class Priority {
public static void main(String[] args) {
// 需要在进程类中添加一个 priority 属性
Collections.sort(processes, (p1, p2) -> p1.priority - p2.priority);
// ...
}
}
```
最后,我们可以通过键盘输入控制选择算法:
```java
public class Scheduler {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int choice = sc.nextInt();
switch (choice) {
case 1:
FCFS.main(args);
break;
case 2:
SJF.main(args);
break;
case 3:
RR.main(args);
break;
case 4:
Priority.main(args);
break;
default:
System.out.println("无效的选择");
}
}
}
```
以上代码仅提供了一个基本的实现方案,具体实现可以根据需求进行修改。