Question

Need help implementing 3 of the following scheduling algorithms: First Come First Served (FCFS), Shortest Job First (SJF), Priority Scheduling, or Round Robin by creating a Java program to run a simulation. Create a Process class that will contain necessary information about the process such as process id, running time, arrival time, priority, etc. Then, create another class called Scheduler, in which you will have a List or Queue of Process objects, along with methods for each of the scheduling algorithms. Your program should input information for 10 processes from the user (or set the values in the program code), display the order in which they will run, along with each process’ wait time and turnaround time – then, compute and display the average wait time and average turnaround time.

Sample variables for the Process class: pid: process id (unique value) burstTime: running time
arrivalTime: arrival time
priority: priority
waitTime: wait time (initialized to 0)
Hints for program:
*In the Process class - Create a constructor that will take parameters to initialize pid, burstTime, arrivalTime, and priority; waitTime will be initialized to 0 in the constructor. Create get methods for each of the variables. Include a method called waiting() that will increment the waitTime variable.
*In the Scheduler class – Include methods for each of the scheduling algorithms (FCFS, SJF, or priority). Choose the most appropriate data structure to store the process objects (either an ArrayList (or List), Queue, or Stack), which can either be an instance variable of the class, or setup as a parameter to each of the scheduling methods.
[In the methods it would be useful to create a time variable (counter). Based on the time and algorithm, select which process will run (will need to keep track of remaining running time). While a process is running, will need to call the waiting() method on all processes that have arrived but are not yet running.]
*Create a RunScheduler class that contains a main method that will run the simulation. Create the list, or queue, of processes and run each of the 32 algorithms using the methods of the Scheduler class.

Answer 1

To implement the First Come First Served (FCFS) and Shortest Job First (SJF) scheduling algorithms, you can create a Java program that simulates the execution of a set of processes. The program should have a Process class that stores information about each process, such as process ID, running time, arrival time, and priority. The class should also have a waiting() method that increments the wait time for each process that has not yet started running.

Next, create a Scheduler class that has a list or queue of Process objects and methods for each of the scheduling algorithms. For FCFS, simply run each process in the order in which it arrived. For SJF, sort the processes by their running time and execute the shortest process first.

In the main method of a RunScheduler class, you can input information for 10 processes or set their values in the program code. Then, use the Scheduler class to run each of the scheduling algorithms and display the order in which the processes will run, along with each process' wait time and turnaround time. Finally, compute and display the average wait time and average turnaround time.

To implement Priority Scheduling and Round Robin, you would need to modify the Scheduler class accordingly. For Priority Scheduling, sort the processes by their priority and execute the highest priority process first. For Round Robin, allocate a fixed time slice to each process and execute each process in a circular queue.

Overall, the key to implementing these scheduling algorithms is to choose the appropriate data structure (such as an ArrayList, Queue, or Stack) to store the process objects and to keep track of the remaining running time for each process.