Three processes arrive simultaneously. Process C requires 100ms of CPU time; processes A and B each require 1ms. Under FCFS with arrival order C → A → B, what is the average waiting time?
A0ms — since all three arrive simultaneously, FCFS distributes wait time equally
B34ms — FCFS computes waiting time as total_time / number_of_processes
CApproximately 67ms — C waits 0ms, A waits 100ms, B waits 101ms; average = 201/3 ≈ 67ms
D1ms — short processes dominate the average because there are more of them
C runs first (arrives first), so A must wait the entire 100ms for C to finish, and B must wait 100ms + 1ms for both C and A. Average = (0 + 100 + 101) / 3 ≈ 67ms. If the arrival order were A → B → C, the average would be (0 + 1 + 2) / 3 ≈ 1ms. This dramatic difference illustrates the convoy effect: the average waiting time under FCFS depends heavily on arrival order, not just on job characteristics.
Question 2 Multiple Choice
A student argues that FCFS scheduling is bad because it causes starvation — some processes never get the CPU. Is this correct?
AYes — long processes can keep getting scheduled repeatedly, permanently delaying short ones
CNo — FCFS is non-preemptive and runs each process to completion in arrival order; every process in the queue eventually reaches the front
DNo — FCFS uses time slicing, so all processes share the CPU fairly and none starve
Starvation occurs in algorithms where some processes can be indefinitely bypassed — for example, priority scheduling where a constant stream of high-priority arrivals prevents low-priority processes from ever running. FCFS has no such mechanism: it is purely order-based and non-preemptive. Once a process joins the queue, it moves steadily toward the front as processes ahead of it complete. No process can cut in line. FCFS's weakness is poor average waiting time (the convoy effect), not starvation.
Question 3 True / False
In FCFS scheduling, if three short I/O-bound processes arrive just after a long CPU-bound process starts, all three must wait the entire duration of the long process before receiving any CPU time.
TTrue
FFalse
Answer: True
This is the convoy effect in action. Because FCFS is non-preemptive, the running process keeps the CPU until it finishes voluntarily or blocks. The three short processes join the ready queue behind the long one and have no mechanism to preempt it — they must wait regardless of how brief their own CPU needs are. If the long process takes 500ms and each short process needs only 2ms, all three wait at least 500ms before their turn arrives.
Question 4 True / False
FCFS scheduling causes starvation because processes that arrive later should usually wait longer, and a process can wait indefinitely if the queue is generally non-empty.
TTrue
FFalse
Answer: False
Waiting longer is not the same as starvation. Starvation means a process is indefinitely blocked from running — it never completes. In FCFS, every process that enters the queue will eventually reach the front, because processes ahead of it will complete (they are never preempted back into the queue after joining). A newly arriving process always joins behind existing ones, but existing ones always move forward. As long as the queue drains, every process eventually runs. Poor waiting time ≠ starvation.
Question 5 Short Answer
What is the convoy effect in FCFS scheduling, and why does it harm I/O device utilization?
Think about your answer, then reveal below.
Model answer: The convoy effect occurs when short I/O-bound processes queue behind a long CPU-bound process. Because FCFS is non-preemptive, the short processes cannot run until the long one finishes. During this entire period, the I/O devices those short processes would use sit idle — the CPU is busy but I/O subsystems are starved of work. When the short processes finally get the CPU, they complete their small bursts quickly and issue I/O requests, but the opportunity for concurrent CPU+I/O overlap during the long process's run has been lost. The result is reduced overall system throughput even though the CPU appears busy.
The deeper point is that modern systems achieve throughput through parallelism: while the CPU executes one process, another should be doing I/O. FCFS destroys this overlap by forcing I/O-bound processes to idle behind a long CPU-bound one. Algorithms like Shortest Job First or Round Robin mitigate this by allowing shorter or time-sliced jobs to interleave with long ones, keeping I/O devices active.