Round Robin Scheduling Program in Java

Round Robin (RR) algorithm is a CPU scheduling algorithm. It is also used in network schedulers. It is especially designed for time sharing system. It is also known as time slicing scheduling algorithm. It is closely similar to FCFS scheduling. In this section, we will discuss the round robin scheduling algorithm and its implementation in a Java program.

Round Robin Algorithm

Round Robin scheduling is the preemptive process scheduling algorithm. Each process is provided a fix time to execute in cyclic way. The fixed time is called the time quantum or time slot or time stamp or time slice. Once a process is executed for a given time period, it is preempted and other process executes for a given time period. Context switching is used to save states of preempted processes. The objective of the algorithm is to maximize the CPU utilization. The algorithm is best suited for time sharing system.

There are the following three variants of Round Robin algorithm:

Deficit Round Robin
Selfish Round Robin
Skip Round Robin

Before moving to the example, first we will understand the various time related to a process used in Round Robin algorithm.

Arrival Time: It is the time when a process enters into the ready state. It means the process is ready for execution. It is calculated as:

Response time = Time at which the process gets the CPU for the first time - Arrival time

Response Time: It is the time when a process gets the CPU for the first time.
Turnaround Time: It is an amount of time the process exists in the system. It is calculated by using the following formulas:

Turnaround Time = Completion Time - Arrival Time
or
Turnaround Time = Burst Time + Waiting Time

Waiting Time: It is an amount of time taken by a process for their complete execution. In other words, the time spend by a process in the ready state waiting for CPU. It is computed by using the following formula:

Burst Time: Burst time is the total time taken by the process for its execution on the CPU. It is also known as execution time.
Completion Time: It is an amount of time taken by a process to complete. It is also known as exit time.
Throughput Time: It can be defined as the number of processes executed by the CPU in a given amount of time. It is used to find the efficiency of a CPU.

Advantage of Round Robin Scheduling

It is cyclic in nature.
It never leads to starvation.
Each task is served by CPU for a fixed time.
Not priorities any task.
It is the same as FCFS scheduling.

Round Robin Scheduling Java Program

RoundRobin.java

import java.util.Scanner;
public class RoundRobin
{
public static void main(String args[])
{
int n,i,qt,count=0,temp,sq=0,bt[],wt[],tat[],rem_bt[];
float awt=0,atat=0;
bt = new int[10];
wt = new int[10];
tat = new int[10];
rem_bt = new int[10];
Scanner s=new Scanner(System.in);
System.out.print("Enter the number of process (maximum 10) = ");
n = s.nextInt();
System.out.print("Enter the burst time of the process\n");
for (i=0;i<n;i++)
{
System.out.print("P"+i+" = "); 
bt[i] = s.nextInt();
rem_bt[i] = bt[i];
}
System.out.print("Enter the quantum time: ");
qt = s.nextInt();
while(true)
{
for (i=0,count=0;i<n;i++)
{
temp = qt;
if(rem_bt[i] == 0)
{
count++;
continue;
}
if(rem_bt[i]>qt)
rem_bt[i]= rem_bt[i] - qt;
else
if(rem_bt[i]>=0)
{
temp = rem_bt[i];
rem_bt[i] = 0;
}
sq = sq + temp;
tat[i] = sq;
}
if(n == count)
break;
}
System.out.print("--------------------------------------------------------------------------------");
System.out.print("\nProcess\t      Burst Time\t       Turnaround Time\t          Waiting Time\n");
System.out.print("--------------------------------------------------------------------------------");
for(i=0;i<n;i++)
{
wt[i]=tat[i]-bt[i];
awt=awt+wt[i];
atat=atat+tat[i];
System.out.print("\n "+(i+1)+"\t "+bt[i]+"\t\t "+tat[i]+"\t\t "+wt[i]+"\n");
}
awt=awt/n;
atat=atat/n;
System.out.println("\nAverage waiting Time = "+awt+"\n");
System.out.println("Average turnaround time = "+atat);
}
}

Output: