fork download
copy 
  1. import java.util.*;
  2.  
  3. class Process {
  4.     private String name;
  5.     private int arrivalTime;
  6.     private int serviceTime;
  7.     private int executionTime;
  8.  
  9.     Process(String name, int arrivalTime, int serviceTime) {
  10.         this.name = name;
  11.         this.arrivalTime = arrivalTime;
  12.         this.serviceTime = serviceTime;
  13.         executionTime = 0;
  14.     }
  15.  
  16.     public void incExecTime() {
  17.         executionTime++;
  18.     }
  19.  
  20.     public int getWaitingTime(int cTime) {
  21.         return cTime - arrivalTime;
  22.     }
  23.  
  24.     public int getRemainingTime() {
  25.         return serviceTime - executionTime;
  26.     }
  27.  
  28.     public String getName() {
  29.         return name;
  30.     }
  31.  
  32.     public boolean isFinished() {
  33.         if (serviceTime == executionTime)
  34.             return true;
  35.         else
  36.             return false;
  37.     }
  38. }
  39.  
  40. class ProcessController {
  41.     static private String processNames[] = { "A", "B", "C", "D", "E", "A", "B", "C", "D", "E" };
  42.     static private int arrivalTimes[] = { 0, 2, 4, 6, 8, 30, 32, 34, 36, 38 };
  43.     static private int serviceTimes[] = { 3, 6, 4, 5, 2, 6, 3, 4, 5, 2 };
  44.     static private int index;
  45.  
  46.     static public void reset() {
  47.         index = 0;
  48.     }
  49.  
  50.     static public boolean hasNextProcess() {
  51.         return index < arrivalTimes.length;
  52.     }
  53.  
  54.     static public Process checkNewProcessArrival(int currentTime) {
  55.         if ((index < arrivalTimes.length) && (arrivalTimes[index] == currentTime)) {
  56.             int i = index++;
  57.             return new Process(processNames[i], arrivalTimes[i], serviceTimes[i]);
  58.         }
  59.         return null;
  60.     }
  61. }
  62.  
  63. abstract class Scheduler {
  64.     private String name;
  65.     protected int currentTime;
  66.     protected Process currentProcess;
  67.     protected boolean isNewProcessArrived;
  68.     protected LinkedList<Process> readyQueue;
  69.  
  70.     Scheduler(String name) {
  71.         this.name = name;
  72.         currentTime = -1;
  73.         currentProcess = null;
  74.         isNewProcessArrived = false;
  75.         readyQueue = new LinkedList<Process>();
  76.         ProcessController.reset();
  77.     }
  78.  
  79.     public void addReadyQueue(Process p) {
  80.         readyQueue.add(p);
  81.     }
  82.  
  83.     public boolean isThereAnyProcessToExecute() {
  84.         return (ProcessController.hasNextProcess() || (currentProcess != null) || !readyQueue.isEmpty());
  85.     }
  86.  
  87.     public String getName() {
  88.         return name;
  89.     }
  90.  
  91.     public void schedule() {
  92.         if ((currentProcess != null) && currentProcess.isFinished()) {
  93.             readyQueue.remove(currentProcess);
  94.             currentProcess = null;
  95.         }
  96.     }
  97.  
  98.     public void clockInterrupt() {
  99.         currentTime++;
  100.         if (currentProcess != null) {
  101.             currentProcess.incExecTime();
  102.             System.out.print(currentProcess.getName());
  103.         } else
  104.             System.out.print(" ");
  105.  
  106.         Process p = ProcessController.checkNewProcessArrival(currentTime);
  107.         isNewProcessArrived = (p != null);
  108.         if (isNewProcessArrived)
  109.             addReadyQueue(p);
  110.     }
  111. }
  112.  
  113. class SRT extends Scheduler {
  114.     SRT(String name) {
  115.         super(name);
  116.     }
  117.  
  118.     @Override
  119.     public void schedule() {
  120.         super.schedule();
  121.         Process nextProcess = readyQueue.peek();
  122.  
  123.         for (var p : readyQueue)
  124.             if (p.getRemainingTime() < nextProcess.getRemainingTime())
  125.                 nextProcess = p;
  126.         currentProcess = nextProcess;
  127.     }
  128.  
  129.     @Override
  130.     public void clockInterrupt() {
  131.         super.clockInterrupt();
  132.         if (isNewProcessArrived || ((currentProcess != null) && currentProcess.isFinished()))
  133.             schedule();
  134.     }
  135. }
  136.  
  137. class RR extends Scheduler {
  138.     private int quantum;
  139.     private int execTime;
  140.  
  141.     RR(String name, int qauntum) {
  142.         super(name);
  143.         this.quantum = qauntum;
  144.         execTime = 0;
  145.     }
  146.  
  147.     @Override
  148.     public void schedule() {
  149.         super.schedule();
  150.         if (currentProcess == null) {
  151.             currentProcess = readyQueue.peek();
  152.         } else {
  153.             readyQueue.remove();
  154.             addReadyQueue(currentProcess);
  155.             currentProcess = readyQueue.peek();
  156.         }
  157.     }
  158.  
  159.     @Override
  160.     public void clockInterrupt() {
  161.         super.clockInterrupt();
  162.         if ((currentProcess != null) && currentProcess.isFinished() || (quantum == execTime)
  163.                 || (currentProcess == null && isNewProcessArrived)) {
  164.             schedule();
  165.             execTime = 1; // 이 부분에서 애먹었습니다.
  166.         } else {
  167.             execTime += 1;
  168.         }
  169.     }
  170. }
  171.  
  172. public class SchedulingApp_20184218 {
  173.  
  174.     public static void printEpilog(Scheduler scheduler) {
  175.         System.out.println("\nScheduling Algorithm: " + scheduler.getName() + "\n");
  176.         System.out.println("0\t1\t2\t3\t4\t5\t\n");
  177.         System.out.println("0123456789012345678901234567890123456789012345678901234\n");
  178.     }
  179.  
  180.     public static void schedAppRun(Scheduler scheduler) {
  181.         printEpilog(scheduler);
  182.  
  183.         while (scheduler.isThereAnyProcessToExecute()) {
  184.             scheduler.clockInterrupt();
  185.             try {
  186.                 Thread.sleep(100);
  187.             } catch (InterruptedException e) {
  188.                 e.printStackTrace();
  189.                 return;
  190.             }
  191.         }
  192.         System.out.println("\n");
  193.     }
  194.  
  195.     public static void main(String[] args) {
  196.         schedAppRun(new SRT("SRT"));
  197.         schedAppRun(new RR("RR q=1", 1));
  198.         schedAppRun(new RR("RR q=4", 4));
  199.     }
  200. }
  201.  
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
Main.java:172: error: class SchedulingApp_20184218 is public, should be declared in a file named SchedulingApp_20184218.java
public class SchedulingApp_20184218 {
       ^
1 error
stdout
copy 
Standard output is empty
https://ideone.com/Gptno7
language:
Java (HotSpot 12)
created:
4 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!