import java.util.*;
private int arrivalTime;
private int serviceTime;
private int executionTime;
this.name = name;
this.arrivalTime = arrivalTime;
this.serviceTime = serviceTime;
executionTime = 0;
}
public void incExecTime() {
executionTime++;
}
public int getWaitingTime(int cTime) {
return cTime - arrivalTime;
}
public int getRemainingTime() {
return serviceTime - executionTime;
}
return name;
}
public boolean isFinished() {
if (serviceTime == executionTime)
return true;
else
return false;
}
}
class ProcessController {
static private String processNames
[] = { "A",
"B",
"C",
"D",
"E",
"A",
"B",
"C",
"D",
"E" }; static private int arrivalTimes[] = { 0, 2, 4, 6, 8, 30, 32, 34, 36, 38 };
static private int serviceTimes[] = { 3, 6, 4, 5, 2, 6, 3, 4, 5, 2 };
static private int index;
static public void reset() {
index = 0;
}
static public boolean hasNextProcess() {
return index < arrivalTimes.length;
}
static public Process checkNewProcessArrival
(int currentTime
) { if ((index < arrivalTimes.length) && (arrivalTimes[index] == currentTime)) {
int i = index++;
return new Process(processNames
[i
], arrivalTimes
[i
], serviceTimes
[i
]); }
return null;
}
}
abstract class Scheduler {
protected int currentTime;
protected boolean isNewProcessArrived;
protected LinkedList<Process> readyQueue;
this.name = name;
currentTime = -1;
currentProcess = null;
isNewProcessArrived = false;
readyQueue = new LinkedList<Process>();
ProcessController.reset();
}
public void addReadyQueue
(Process p
) { readyQueue.add(p);
}
public boolean isThereAnyProcessToExecute() {
return (ProcessController.hasNextProcess() || (currentProcess != null) || !readyQueue.isEmpty());
}
return name;
}
public void schedule() {
if ((currentProcess != null) && currentProcess.isFinished()) {
readyQueue.remove(currentProcess);
currentProcess = null;
}
}
public void clockInterrupt() {
currentTime++;
if (currentProcess != null) {
currentProcess.incExecTime();
System.
out.
print(currentProcess.
getName()); } else
Process p
= ProcessController.
checkNewProcessArrival(currentTime
); isNewProcessArrived = (p != null);
if (isNewProcessArrived)
addReadyQueue(p);
}
}
class SRT extends Scheduler {
super(name);
}
@Override
public void schedule() {
super.schedule();
Process nextProcess
= readyQueue.
peek();
for (var p : readyQueue)
if (p.getRemainingTime() < nextProcess.getRemainingTime())
nextProcess = p;
currentProcess = nextProcess;
}
@Override
public void clockInterrupt() {
super.clockInterrupt();
if (isNewProcessArrived || ((currentProcess != null) && currentProcess.isFinished()))
schedule();
}
}
class RR extends Scheduler {
private int quantum;
private int execTime;
RR
(String name,
int qauntum
) { super(name);
this.quantum = qauntum;
execTime = 0;
}
@Override
public void schedule() {
super.schedule();
if (currentProcess == null) {
currentProcess = readyQueue.peek();
} else {
readyQueue.remove();
addReadyQueue(currentProcess);
currentProcess = readyQueue.peek();
}
}
@Override
public void clockInterrupt() {
super.clockInterrupt();
if ((currentProcess != null) && currentProcess.isFinished() || (quantum == execTime)
|| (currentProcess == null && isNewProcessArrived)) {
schedule();
execTime = 1; // 이 부분에서 애먹었습니다.
} else {
execTime += 1;
}
}
}
public class SchedulingApp_20184218 {
public static void printEpilog(Scheduler scheduler) {
System.
out.
println("\nScheduling Algorithm: " + scheduler.
getName() + "\n"); System.
out.
println("0\t1\t2\t3\t4\t5\t\n"); System.
out.
println("0123456789012345678901234567890123456789012345678901234\n"); }
public static void schedAppRun(Scheduler scheduler) {
printEpilog(scheduler);
while (scheduler.isThereAnyProcessToExecute()) {
scheduler.clockInterrupt();
try {
e.printStackTrace();
return;
}
}
}
public static void main
(String[] args
) { schedAppRun(new SRT("SRT"));
schedAppRun(new RR("RR q=1", 1));
schedAppRun(new RR("RR q=4", 4));
}
}