/** This code bit involves implementing several different process scheduling algorithms. The scheduler will be assigned a predefined set of tasks and will schedule the tasks based on the selected scheduling algorithm. Each task is assigned a priority and CPU burst. The following scheduling algorithms will be implemented: • First-come,first-served(FCFS), which schedules tasks in the order in which they request the CPU. • Shortest-job-first (SJF), which schedules tasks in order of the length of the tasks’ next CPU burst. • Priority scheduling, which schedules tasks based on priority. • Round-robin (RR) scheduling, where each task is run for a time quantum (or for the remainder of its CPU burst). • Priority with round-robin, which schedules tasks in order of priority and uses round-robin scheduling for tasks with equal priority. Priorities range from 1 to 10, where a higher numeric value indicates a higher relative priority. For round-robin scheduling, the length of a time quantum is 10 milliseconds.*/ import java.util.List; import java.util.ArrayList; import java.util.Comparator; public class ScheduleAlgo { public static void main(String[] args) { // generate sample tasks List tasks = new ArrayList<>(); tasks.add(new Task(1, 4, 20)); tasks.add(new Task(2, 1, 25)); tasks.add(new Task(3, 10, 15)); tasks.add(new Task(4, 5, 23)); tasks.add(new Task(5, 3, 10)); // create 3 different schedulers Scheduler fcfs = new FCFS(); Scheduler sjf = new SJF(); Scheduler ps = new PrioritySchedule(); // assign tasks for(Task task:tasks){ fcfs.addTask(task); sjf.addTask(task); ps.addTask(task); } // schedule fcfs.schedule(); sjf.schedule(); ps.schedule(); // view System.out.println("Fist-Come-First-Served scheduler\n"); fcfs.view(); System.out.println("\n Shortest-Job-First scheduler\n"); sjf.view(); System.out.println("\n Priority Schedule scheduler\n"); ps.view(); } } class Task{ private final int ID; private final int PRIORITY_LEVEL; private final int CPU_BURST; public Task(int id, int priority, int cpuBurst){ ID = id; PRIORITY_LEVEL = priority; CPU_BURST = cpuBurst; } public int getId(){ return ID; } public int getPriority(){ return PRIORITY_LEVEL; } public int getCpuBurst(){ return CPU_BURST; } @Override public String toString (){ return String.format("Task(Id=%d, Priority=%d, CpuBurst=%d)", ID, PRIORITY_LEVEL, CPU_BURST); } } interface Scheduler{ void schedule(); List getTasks(); default void addTask(Task task){ getTasks().add(task); } default void view (){ getTasks().stream().forEach(e -> System.out.println(e)); System.out.println("\n******************************************"); } } /** First-Come-First-Served*/ class FCFS implements Scheduler{ private List tasks = new ArrayList<>(); @Override public List getTasks(){ return tasks; } @Override public void schedule(){ tasks.sort(new Comparator(){ @Override public int compare(Object o1, Object o2){ Task task1 = (Task) o1; Task task2 = (Task) o2; return Integer.compare(task1.getId(), task2.getId()); } }); } } /** Shortest-Job-First*/ class SJF implements Scheduler{ private List tasks = new ArrayList<>(); @Override public List getTasks(){ return tasks; } @Override public void schedule(){ tasks.sort(new Comparator(){ @Override public int compare(Object o1, Object o2){ Task task1 = (Task) o1; Task task2 = (Task) o2; return Integer.compare(task1.getCpuBurst(), task2.getCpuBurst()); } }); } } /** Priority scheduling*/ class PrioritySchedule implements Scheduler{ private List tasks = new ArrayList<>(); @Override public List getTasks(){ return tasks; } @Override public void schedule(){ tasks.sort(new Comparator(){ @Override public int compare(Object o1, Object o2){ Task task1 = (Task) o1; Task task2 = (Task) o2; return Integer.compare(task1.getPriority(), task2.getPriority()); } }); } } /**Round Robin*/ class RoundRobin implements Scheduler{ // todo: under-development @Override public List getTasks(){ return new ArrayList(); } public void schedule (){} public void view (){} }

CPU Task Schedule Algorithms