FCFS Program in Java with Arrival Time

What is FCFS scheduling algorithm?

First Come, First Served (FCFS) is a non-primitive CPU scheduling algorithm. It schedules processes in the order in which they arrive in the ready queue. Processes are executed one by one until completion.

What is arrival time?

Arrival time is the time at which a process arrives in the ready queue.

Non-primitive: Non-primitive scheduling is employed when a process terminates or transitions from running to waiting state.

First in, first out (FIFO), also known as first come, first served (FCFS), is the simplest scheduling algorithm. FIFO simply queues processes in the order that they arrive in the ready queue.

In this, the process that comes first will be executed first and next process starts only after the previous gets fully executed.

Here, we are considering that arrival time for all processes is 0.

Completion Time: Time at which process completes its execution.
Turn Around Time: Time Difference between completion time and arrival time. Turn Around Time = Completion Time - Arrival Time
Waiting Time (W.T): Time Difference between turnaround time and burst time.
Waiting Time = Turn Around Time - Burst Time.

Implementation of FCFS

FCFS Algorithm

Input the processes along with their burst time (bt).
Find waiting time (wt) for all processes.
As first process that comes need not to wait so waiting time for process 1 will be 0 i.e. wt[0] = 0.
Find waiting time for all other processes i.e. for process i ->wt[i] = bt[i-1] + wt[i-1]
Find turnaround time = waiting_time + burst_time for all processes.
Find average waiting time = total_waiting_time / no_of_processes.
Similarly, find average turnaround time = total_turn_around_time / no_of_processes.

Given n processes with their burst times, the task is to find average waiting time and average turnaround time using FCFS scheduling algorithm.

FCFS.java

import java.util.*;
public class FCFS {	
	// Process class to represent a process
	static class Process {
		private int at; // arrival time
		private int bt; // burst time
		private int ct; // completion time
		private int tat; // turnaround time
		private int wt; // waiting time
		private int pid; // process ID
		// Getter method to get a variable value of the process
		public int getVar(String var) {
			if (var.equals("at"))
				return at;
			if (var.equals("bt"))
				return bt;
			if (var.equals("ct"))
				return ct;
			if (var.equals("tat"))
				return tat;
			if (var.equals("wt"))
				return wt;
			return pid;
		}
		// Setter method to set a variable value of the process
		public void setVar(String var, int value) {
			if (var.equals("at"))
				at = value;
			else if (var.equals("bt"))
				bt = value;
			else if (var.equals("ct"))
				ct = value;
			else if (var.equals("tat"))
				tat = value;
			else if (var.equals("wt"))
				wt = value;
			else
				pid = value;
		}
		// Update the turnaround time and waiting time after completion
		public void updateAfterCt() {
			tat = ct - at;
			wt = tat - bt;
		}
		// Display the process details
		public void display() {
			System.out.printf("%d\t%d\t%d\t%d\t%d\t%d\n", pid, at, bt, ct, tat, wt);
		}
	}
	// Calculate the average of a variable value for all processes
	public static float average(ArrayList<Process> P, String var) {
		int total = 0;
		for (Process temp : P) {
			total += temp.getVar(var);
		}
		return (float) total / P.size();
	}
	public static void main(String[] args) {
		/*
		Input description.
		First line contains an integer n
		the next n lines contain 2 space separated integers
		containing values for arrival time and burst time for
		example:
		2
		0 3
		1 2
		*/
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int counter = 0;
		ArrayList<Process> P = new ArrayList<Process>(n);
		// Create a process object for each input and add to the process list
		for (int i = 0; i < n; i++) {
			Process temp = new Process();
			temp.setVar("pid", counter++);
			temp.setVar("at", sc.nextInt());
			temp.setVar("bt", sc.nextInt());
			P.add(temp);
		}
		// Sort the process list by arrival time
		Collections.sort(P, new Comparator<Process>() {
			public int compare(Process first, Process second) {
				return first.getVar("at") - second.getVar("at");
			}
		});
		System.out.println("pid\tat\tbt\tct\ttat\twt");
		// Calculate completion time and display the details of the first process
		P.get(0).setVar("ct", P.get(0).getVar("at") + P.get(0).getVar("bt"));
		P.get(0).updateAfterCt();
		P.get(0).display();
		// Calculate completion time and display the details of the remaining processes
	for (int i = 1; i < P.size(); i++) {
		// Loop through the remaining processes
		if (P.get(i).getVar("at") < P.get(i - 1).getVar("ct")) {
			// If the process arrives before the previous process completes
			P.get(i).setVar("ct", P.get(i - 1).getVar("ct") + P.get(i).getVar("bt"));
			// Calculate completion time as the completion time of previous process plus its burst time
		} else {
			// If the process arrives after the previous process completes
			System.out.printf("curr['at'] : %d, prev['ct'] : %d\n\n", P.get(i).getVar("at"),
					P.get(i - 1).getVar("ct"));
			P.get(i).setVar("ct", P.get(i).getVar("at") + P.get(i).getVar("bt"));
			// Calculate completion time as the arrival time plus its burst time
		}
		P.get(i).updateAfterCt(); // Update the turnaround time and waiting time for the current process
		P.get(i).display(); // Display the details of the current process
	}
	System.out.printf("Average waiting time : %f\n", average(P, "wt"));
	sc.close(); // Close the scanner
}
}

Output:

PID     AT      BT      CT      TAT     WT
0       0       10      10      10      0
1       10      5       15      5       0
2       15      8       23      8       0
Avg_turnaround:7.666666666666667
Avg_Waitingtime:0.0

Service Time: Also known as Burst Time, it is the amount of time a process requires to complete its execution on the CPU. It represents the time the CPU spends executing instructions of that particular process.

Waiting Time: It refers to the total amount of time that a process spends waiting in the ready queue before it gets a chance to execute on the CPU.

Implementation of FCFS

Input the processes along with their burst time(bt) and arrival time(at)
Find waiting time for all other processes i.e. for a given process i: wt[i] = (bt[0] + bt[1] +...... bt[i-1]) - at[i]
Now find turnaround time = waiting_time + burst_time for all processes
Average waiting time = total_waiting_time / no_of_processes
Average turnaround time = total_turn_around_time / no_of_processes

Let's calculate the average waiting time and turnaround time for the following data.

Processes	Burst Time	Arrival Time	Waiting Time	Turn-Around Time	Completion Time
1	5	0	0	5	5
2	9	3	2	11	14
3	6	6	8	14	20

FCFS.java

public class FCFS{ 
// Java program for implementation of FCFS 
// scheduling with different arrival time 
// Function to find the waiting time for all 
// processes 
static void findWaitingTime(int processes[], int n, int bt[], int wt[], int at[]) 
{ 
	int service_time[] = new int[n]; 
	service_time[0] = at[0]; 
	wt[0] = 0; 
	// calculating waiting time 
	for (int i = 1; i < n ; i++) 
	{ 
		//representing wasted time in queue 
		int wasted=0; 
		// Add burst time of previous processes 
		service_time[i] = service_time[i-1] + bt[i-1]; 
		// Find waiting time for current process = 
		// sum - at[i] 
		wt[i] = service_time[i] - at[i]; 
		// If waiting time for a process is in negative 
		// that means it is already in the ready queue 
		// before CPU becomes idle so its waiting time is 0 
		// wasted time is basically time for process to wait after a process is over 
		if (wt[i] < 0) { 
			wasted = Math.abs(wt[i]); 
			wt[i] = 0; 
		} 
		//Add wasted time 
		service_time[i] = service_time[i] + wasted; 
	} 
} 
// Function to calculate turn around time 
static void findTurnAroundTime(int processes[], int n, int bt[], 
									int wt[], int tat[]) 
{ 
	// Calculating turnaround time by adding bt[i] + wt[i] 
	for (int i = 0; i < n ; i++) 
		tat[i] = bt[i] + wt[i]; 
} 
// Function to calculate average waiting and turn-around 
// times. 
static void findavgTime(int processes[], int n, int bt[], int at[]) 
{ 
	int wt[] = new int[n], tat[] = new int[n]; 
	// Function to find waiting time of all processes 
	findWaitingTime(processes, n, bt, wt, at); 
	// Function to find turnaround time for all processes 
	findTurnAroundTime(processes, n, bt, wt, tat); 
	// Display processes along with all details 
	System.out.print("Processes " + " Burst Time " + " Arrival Time "
		+ " Waiting Time " + " Turn-Around Time "
		+ " Completion Time \n"); 
	int total_wt = 0, total_tat = 0; 
	for (int i = 0 ; i < n ; i++) 
	{ 
		total_wt = total_wt + wt[i]; 
		total_tat = total_tat + tat[i]; 
		int compl_time = tat[i] + at[i]; 
		System.out.println(i+1 + "\t\t" + bt[i] + "\t\t"
			+ at[i] + "\t\t" + wt[i] + "\t\t "
			+ tat[i] + "\t\t " + compl_time); 
	} 
	System.out.print("Average waiting time = "
		+ (float)total_wt / (float)n); 
	System.out.print("\nAverage turnaround time = "
		+ (float)total_tat / (float)n); 
} 
// Driver code 
	public static void main(String args[]) { 
		// Process id's 
	int processes[] = {1, 2, 3}; 
	int n = processes.length; 
	// Burst time of all processes 
	int burst_time[] = {5, 9, 6}; 
	// Arrival time of all processes 
	int arrival_time[] = {0, 3, 6}; 
	findavgTime(processes, n, burst_time, arrival_time); 
	} 
} 

Output:

Average waiting time = 3.33333
Average turnaround time = 10.0

Next TopicImmutable Map in Java

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

FCFS Program in Java with Arrival Time

What is FCFS scheduling algorithm?

What is arrival time?

Implementation of FCFS

FCFS Algorithm

Implementation of FCFS

Feedback

Help Others, Please Share

Learn Latest Tutorials

Preparation

Trending Technologies

B.Tech / MCA