First Come First Served (FCFS)

The ready queue is a plain FIFO queue. A process arriving is pushed on the back; when the CPU frees up, the process at the front is dispatched and runs until it finishes or blocks. There is no priority, no estimate, no preemption — nothing to compute, which is why it is the easiest scheduler to implement and the baseline everything else is compared to.

Arrival time

When the process shows up in the ready queue. The scheduler cannot pick something that has not arrived yet — that single rule decides most exam answers.

Burst time

How long this process needs the CPU for, uninterrupted, before it would block or finish. Also called CPU burst.

Ready queue

Every process that could run right now but does not have the CPU. Scheduling is entirely the question of who gets pulled out of here next.

Preemptive vs non-preemptive

A non-preemptive scheduler cannot take the CPU back — once dispatched, a process runs until it blocks or finishes. A preemptive one can interrupt it mid-burst.

Context switch

Saving one process's registers and loading another's. Pure overhead: real work stops while it happens, typically a few microseconds.

Starvation

A process that stays runnable but never gets picked, because something more attractive keeps arriving. The classic fix is ageing — slowly raising the priority of anything that has waited a long time.

FCFS has one serious flaw, and it is worth being able to state precisely: average waiting time depends heavily on the order of arrival, and one long job at the front penalises everyone behind it.

Take three processes all arriving at t = 0 — P1 with a burst of 24, P2 with 3, P3 with 3. In the order P1, P2, P3:

Average waiting time is (0 + 24 + 27) ÷ 3 = 17. Now run exactly the same processes in the order P2, P3, P1: waiting times become 0, 3 and 6, an average of 3. Same work, same machine, nearly six times better — purely because the short jobs went first.

That pile-up of short jobs behind one long one is the convoy effect. In a real system it is worse than the numbers suggest: the I/O devices sit idle while the CPU-bound job hogs the processor, then everything stampedes at once.

Never on its own in an interactive system — a single long job would freeze the machine. It survives as the tie-breaking rule *inside* other schedulers (processes of equal priority are usually served FCFS) and in batch settings where throughput matters and nobody is waiting at a screen.