操作系统实验 实验一 时间-2025.12.09
实验一 进程调度算法的模拟实验 实验目的和要求：通过该实验，加深对多道系统中调度算法的认识和理解，并模拟实现理论课中所学的任一种算法。 仪器设备：微型计算机 实验材料：无 教学方法：个人练习和教师辅导相结合 实验内容提要： 1. 实现先来先服务、短进程优先、高响应比优先、时间片轮转四种调度算法中的任意一种算法。 2. 通过输入一组进程序列计算出在所选算法下应该输出的进程序列。 C include <stdio.h include <stdlib.h
typedef struct { int pid; // 进程ID int arrival; // 到达时间 int burst; // 执行时间 int remaining; // 剩余时间 int completion; // 完成时间 } Process;
void roundRobin(Process processes, int n, int timeQuantum) { int time = 0, completed = 0; int waiting = (int)calloc(n, sizeof(int)); int turnaround = (int)calloc(n, sizeof(int));
// 初始化剩余时间 for(int i = 0; i < n; i++) { processesi.remaining = processesi.burst; }
while(completed < n) { int done = 1; for(int i = 0; i < n; i++) { if(processesi.remaining 0 && processesi.arrival <= time) { done = 0; if(processesi.remaining timeQuantum) { time += timeQuantum; processesi.remaining -= timeQuantum; } else { time += processesi.remaining; processesi.completion = time; processesi.remaining = 0; completed++; } } } if(done) time++; }
printf("PID\tArrival\tBurst\tCompletion\n"); for(int i = 0; i < n; i++) { printf("%d\t%d\t%d\t%d\n", processesi.pid, processesi.arrival, processesi.burst, processesi.completion); }
free(waiting); free(turnaround); }
int main() { Process processes = { {1, 0, 5, 0, 0}, {2, 1, 3, 0, 0}, {3, 2, 8, 0, 0}, {4, 3, 6, 0, 0} }; int n = 4; int timeQuantum = 2;
roundRobin(processes, n, timeQuantum); return 0; } C++ include <iostream include <vector include <queue using namespace std;
class Process { public: int pid; int arrival; int burst; int remaining; int completion;
Process(int p, int a, int b) : pid(p), arrival(a), burst(b), remaining(b), completion(0) {} };
void roundRobin(vector<Process& processes, int timeQuantum) { queue<int readyQueue; vector<bool inQueue(processes.size(), false); int time = 0, completed = 0; int idx = 0;
// 按到达时间排序 sort(processes.begin(), processes.end(), (const Process& a, const Process& b) { return a.arrival < b.arrival; });
while(completed < processes.size()) { // 添加到达的进程 while(idx < processes.size() && processesidx.arrival <= time) { readyQueue.push(idx); idx++; }
if(!readyQueue.empty()) { int current = readyQueue.front(); readyQueue.pop();
int execTime = min(timeQuantum, processescurrent.remaining); time += execTime; processescurrent.remaining -= execTime;
// 再次添加到达的进程 while(idx < processes.size() && processesidx.arrival <= time) { readyQueue.push(idx); idx++; }
if(processescurrent.remaining 0) { readyQueue.push(current); } else { processescurrent.completion = time; completed++; } } else { time++; } }
cout << "PID\tArrival\tBurst\tCompletion\n"; for(auto& p : processes) { cout << p.pid << "\t" << p.arrival << "\t" << p.burst << "\t" << p.completion << endl; } }
int main() { vector<Process processes = { Process(1, 0, 5), Process(2, 1, 3), Process(3, 2, 8), Process(4, 3, 6) };
roundRobin(processes, 2); return 0; } Python class Process: def __init__(self, pid, arrival, burst): self.pid = pid self.arrival = arrival self.burst = burst self.remaining = burst self.completion = 0
def round_robin(processes, time_quantum): n = len(processes) time = 0 completed = 0 ready_queue = processes.sort(key=lambda x: x.arrival) idx = 0
while completed < n: 添加到达的进程 while idx < n and processesidx.arrival <= time: ready_queue.append(idx) idx += 1
if ready_queue: current = ready_queue.pop(0) exec_time = min(time_quantum, processescurrent.remaining) time += exec_time processescurrent.remaining -= exec_time
再次添加到达的进程 while idx < n and processesidx.arrival <= time: ready_queue.append(idx) idx += 1
if processescurrent.remaining 0: ready_queue.append(current) else: processescurrent.completion = time completed += 1 else: time += 1
print("PID\tArrival\tBurst\tCompletion") for p in processes: print(f"{p.pid}\t{p.arrival}\t{p.burst}\t{p.completion}")
if __name__ == "__main__": processes = Process(1, 0, 5), Process(2, 1, 3), Process(3, 2, 8), Process(4, 3, 6) round_robin(processes, 2) Java import java.util.;
class Process { int pid; int arrival; int burst; int remaining; int completion;
public Process(int pid, int arrival, int burst) { this.pid = pid; this.arrival = arrival; this.burst = burst; this.remaining = burst; this.completion = 0; } }
public class RoundRobin { public static void roundRobin(List<Process processes, int timeQuantum) { Queue<Integer readyQueue = new LinkedList<(); processes.sort(Comparator.comparingInt(p - p.arrival)); int time = 0, completed = 0; int idx = 0;
while (completed < processes.size()) { // 添加到达的进程 while (idx < processes.size() && processes.get(idx).arrival <= time) { readyQueue.add(idx); idx++; }
if (!readyQueue.isEmpty()) { int current = readyQueue.poll(); int execTime = Math.min(timeQuantum, processes.get(current).remaining); time += execTime; processes.get(current).remaining -= execTime;
// 再次添加到达的进程 while (idx < processes.size() && processes.get(idx).arrival <= time) { readyQueue.add(idx); idx++; }
if (processes.get(current).remaining 0) { readyQueue.add(current); } else { processes.get(current).completion = time; completed++; } } else { time++; } }
System.out.println("PID\tArrival\tBurst\tCompletion"); for (Process p : processes) { System.out.println(p.pid + "\t" + p.arrival + "\t" + p.burst + "\t" + p.completion); } }
public static void main(String args) { List<Process processes = Arrays.asList( new Process(1, 0, 5), new Process(2, 1, 3), new Process(3, 2, 8), new Process(4, 3, 6) );
roundRobin(processes, 2); } } C using System; using System.Collections.Generic;
class Process { public int pid; public int arrival; public int burst; public int remaining; public int completion;
public Process(int pid, int arrival, int burst) { this.pid = pid; this.arrival = arrival; this.burst = burst; this.remaining = burst; this.completion = 0; } }
class RoundRobinScheduler { public static void RoundRobin(List<Process processes, int timeQuantum) { Queue<int readyQueue = new Queue<int(); processes.Sort((a, b) = a.arrival.CompareTo(b.arrival)); int time = 0, completed = 0; int idx = 0;
while (completed < processes.Count) { // 添加到达的进程 while (idx < processes.Count && processesidx.arrival <= time) { readyQueue.Enqueue(idx); idx++; }
if (readyQueue.Count 0) { int current = readyQueue.Dequeue(); int execTime = Math.Min(timeQuantum, processescurrent.remaining); time += execTime; processescurrent.remaining -= execTime;
// 再次添加到达的进程 while (idx < processes.Count && processesidx.arrival <= time) { readyQueue.Enqueue(idx); idx++; }
if (processescurrent.remaining 0) { readyQueue.Enqueue(current); } else { processescurrent.completion = time; completed++; } } else { time++; } }
Console.WriteLine("PID\tArrival\tBurst\tCompletion"); foreach (Process p in processes) { Console.WriteLine($"{p.pid}\t{p.arrival}\t{p.burst}\t{p.completion}"); } }
static void Main() { List<Process processes = new List<Process { new Process(1, 0, 5), new Process(2, 1, 3), new Process(3, 2, 8), new Process(4, 3, 6) };
RoundRobin(processes, 2); } }