# Scheduling Algorithm : First Come First Serve (fcfs) Java Program Code

Scheduling algorithm is used by CPU scheduler to select a process .  There are many types of scheduling algorithm but we will discuss about the most common  algorithm FCFS i.e. First come and First Serve .
By applying this scheduling algorithm  , the CPU makes sure that the process which is run by user are lined
in queue , just like the queue for buying tickets of movie . The person who comes first , will have the chance to get the ticket , similarly , if  CPU is idle  and  CPU is using First come and First Serve algorithm then ,it
executes the process which arrives first .

Read Also  :     Round Robin Scheduling Algorithm with Example

Here , User can calculate the average turnaround time and average waiting time along with the starting and finishing time of each process

Turnaround time   :   Its the total time taken by the process between starting and the completion

Waiting time         :   Its the time for which process is ready to run but not executed by CPU scheduler

for example ,
we have three processes

Burst time             Waiting time         Turnaround time

P1                          18                           0                           18

P2                          5                             18                         23

P3                          7                             23                         30

So here we can see the turnaround time for the process 1 is 18 while 23 and 30 for 2nd and 3rd process

Gantt chart for the turnaround time is

|----------------------------------------------------|------------------|------------------------|
|                            P1                                              |       P2                |             P3                  |
|----------------------------------------------------|------------------|------------------------|
0                                                                               18                       23                                30

A Gantt chart is a chart which shows the start and finish times of  all the processes .

Also first come first serve algorithm is non preemptive so if the process starts then the other process has to wait in the queue till the executing process finishes .

The major features of the First come first serve algorithm is that

* Throughput is low as the large process is holding up the Central processing unit for execution .
* The main disadvantage of FCFS is starving . As long as all processes completes the execution then we
dont have any trouble, But the problem starts when any of the process fails to complete . The incomplete
execution of any process leads to starvation .
*  Queuing is done without using any prioritization of the processes.

Demo :

```import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Queue;

/* implement this class for all three strategies */

public abstract class AllocationStrategy {
protected List<Job> Jobs;
protected ArrayList<Job> Queue;

public AllocationStrategy(List<Job> jobs) {
super();
Jobs = jobs;
}

public abstract void run();
// update current job by 1 tick
// check if the job queue might need to be changed.
// check for jobs to add to the queue
}

FirstComeFirstServed.java

import java.util.ArrayList;
import java.util.List;

public class FirstComeFirstServed extends AllocationStrategy {

int temp;
int proceessArrivalTime;
int waitingTime;
double avgWaitingTime;
double avgTurnAroundTime;

public FirstComeFirstServed(List<Job> jobs) {
super(jobs);
}

@Override
public void run() {

}

public void run(List<Job> jobList) {
int count = 0;
System.out.println("============================================ ");
System.out.println("Process ID | Turnaround time | Waiting time ");
System.out.println("============================================ ");
for(Job job:jobList){
if(count==0){
job.processArrivalTime = job.getArrivalTime();
job.ProcessCompletionTime = job.getArrivalTime()+job.getCpuTime();
}else{
job.processArrivalTime = temp-job.getArrivalTime();
job.ProcessCompletionTime = temp+job.getCpuTime();
}

temp = job.ProcessCompletionTime;
job.turnAroundTime = temp-job.getArrivalTime();
job.waitingTime = job.turnAroundTime-job.getCpuTime();
count++;

avgWaitingTime =  avgWaitingTime+job.waitingTime;
avgTurnAroundTime = avgTurnAroundTime+job.turnAroundTime;
System.out.println("   "+job.getProcessId()+"  | "+"   "+job.turnAroundTime+"  | "+"   "+job.waitingTime+" ");
System.out.println("----------------------------------------");
}
System.out.println("===============================================");
System.out.println("Avg waiting time:"+avgWaitingTime/jobList.size());
System.out.println("===============================================");
System.out.println("Avg turn around time:"+avgTurnAroundTime/jobList.size());
System.out.println("===============================================");

}

}

Job.java

public class Job {
private int id, submitTime, CPUTime, CPUTimeLeft;

private int startTime = 0, endTime = 0;

public int ProcessCompletionTime;
public int processArrivalTime;
public int waitingTime;
public int turnAroundTime;
private JobFinishEvent evt;

private int arrivalTime,cpuTime,processId;

public Job(int id, int submitTime, int CPUTime, JobFinishEvent evt) {
super();
this.id = id;
this.submitTime = submitTime;
this.CPUTime = CPUTime;
this.CPUTimeLeft = CPUTime;
this.evt = evt;
}

public Job(int processId, int arrivalTime, int cpuTime) {

this.processId = processId;
this.arrivalTime = arrivalTime;
this.cpuTime = cpuTime;

}

public void start(int sysTime) {
startTime = sysTime;
}

public void tick(int sysTime) {
CPUTimeLeft --;
if (CPUTimeLeft <= 0){
endTime = sysTime;
evt.onFinish(this);
}

}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public int getSubmitTime() {
return submitTime;
}

public void setSubmitTime(int submitTime) {
this.submitTime = submitTime;
}

public int getCPUTime() {
return CPUTime;
}

public void setCPUTime(int cPUTime) {
CPUTime = cPUTime;
}

public int getCPUTimeLeft() {
return CPUTimeLeft;
}

public void setCPUTimeLeft(int cPUTimeLeft) {
CPUTimeLeft = cPUTimeLeft;
}

public int getStartTime() {
return startTime;
}

public void setStartTime(int startTime) {
this.startTime = startTime;
}

public int getEndTime() {
return endTime;
}

public void setEndTime(int endTime) {
this.endTime = endTime;
}

public int getArrivalTime() {
return arrivalTime;
}

public void setArrivalTime(int arrivalTime) {
this.arrivalTime = arrivalTime;
}

public int getCpuTime() {
return cpuTime;
}

public void setCpuTime(int cpuTime) {
this.cpuTime = cpuTime;
}

public int getProcessId() {
return processId;
}

public void setProcessId(int processId) {
this.processId = processId;
}

}

JobFinishEvent.java

public interface JobFinishEvent {
public void onFinish(Job j);
}

Question1.java

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
* Application class for Assignment 1, Question 1, compsci215 2013
*
* @author dber021
*
*/
public class Question1 {

public static void main(String[] args) {
// Process command line arguments

Scanner sc = new Scanner(System.in);
Scanner sc1 = new Scanner(System.in);
Scanner sc2 = new Scanner(System.in);

String filename ;
String allocationStrategy;
int quantum=20;

/*filename = args[0];
allocationStrategy = args[1];*/

filename = "testing.txt";
allocationStrategy = "FCFS";

//filename = sc.nextLine();

if(args.length==3){
quantum = new Integer(args[2]);
}

try {

String sCurrentLine;

//System.out.println("processId  arrivalTime  cpuTime");

List<Job> jobList = new ArrayList<Job>();
while ((sCurrentLine = br.readLine()) != null) {

String a[] = sCurrentLine.split(",");
int processId = new Integer(a[0]);
int arrivalTime = new Integer(a[1]);
int cpuTime = new Integer(a[2]);

Job job = new Job(processId,arrivalTime,cpuTime);

//System.out.println(processId+" "+ arrivalTime+" " + cpuTime);
}

if("FCFS".equalsIgnoreCase(allocationStrategy)){

FirstComeFirstServed firstComeFirstServed = new FirstComeFirstServed(jobList);
firstComeFirstServed.run(jobList);

}else if("SRT".equalsIgnoreCase(allocationStrategy)){

ShortestRemainingTime shortestRemainingTime = new ShortestRemainingTime(jobList);
shortestRemainingTime.run(jobList);

}else if("RR".equalsIgnoreCase(allocationStrategy)){

RoundRobin roundRobin = new RoundRobin();
roundRobin.run(jobList,quantum);

}

} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br != null)br.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}

JobFinishEvent callback = new JobFinishEvent() {
@Override
public void onFinish(Job j) {
// this will be called when a job is finished.
}
};

ArrayList jobs = new ArrayList();
FirstComeFirstServed fcfs = new FirstComeFirstServed(jobs);
fcfs.run();
*/
}

}
```