SJFScheduling.java

package com.thealgorithms.scheduling;

import com.thealgorithms.devutils.entities.ProcessDetails;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

/**
 * Shortest Job First (SJF) Scheduling Algorithm:
 * Executes processes with the shortest burst time first among the ones that have arrived.
 */
public class SJFScheduling {
 private final List<ProcessDetails> processes;
 private final List<String> schedule;

 public SJFScheduling(final List<ProcessDetails> processes) {
 this.processes = new ArrayList<>(processes);
 this.schedule = new ArrayList<>();
 sortProcessesByArrivalTime(this.processes);
 }

 private static void sortProcessesByArrivalTime(List<ProcessDetails> processes) {
 processes.sort(Comparator.comparingInt(ProcessDetails::getArrivalTime));
 }

 /**
 * Executes the SJF scheduling algorithm and builds the execution order.
 */
 public void scheduleProcesses() {
 List<ProcessDetails> ready = new ArrayList<>();
 int size = processes.size();
 int time = 0;
 int executed = 0;

 Iterator<ProcessDetails> processIterator = processes.iterator();

 // This will track the next process to be checked for arrival time
 ProcessDetails nextProcess = null;
 if (processIterator.hasNext()) {
 nextProcess = processIterator.next();
 }

 while (executed < size) {
 // Load all processes that have arrived by current time
 while (nextProcess != null && nextProcess.getArrivalTime() <= time) {
 ready.add(nextProcess);
 if (processIterator.hasNext()) {
 nextProcess = processIterator.next();
 } else {
 nextProcess = null;
 }
 }

 ProcessDetails running = findShortestJob(ready);
 if (running == null) {
 time++;
 } else {
 time += running.getBurstTime();
 schedule.add(running.getProcessId());
 ready.remove(running);
 executed++;
 }
 }
 }

 /**
 * Finds the process with the shortest job of all the ready processes (based on a process
 * @param readyProcesses an array list of ready processes
 * @return returns the process' with the shortest burst time OR NULL if there are no ready
 * processes
 */
 private ProcessDetails findShortestJob(Collection<ProcessDetails> readyProcesses) {
 return readyProcesses.stream().min(Comparator.comparingInt(ProcessDetails::getBurstTime)).orElse(null);
 }

 /**
 * Returns the computed schedule after calling scheduleProcesses().
 */
 public List<String> getSchedule() {
 return schedule;
 }

 public List<ProcessDetails> getProcesses() {
 return List.copyOf(processes);
 }
}