Preemptive Scheduling vs. Non-Preemptive Scheduling

In a multitasking operating system, the CPU is the most critical and contested resource. The CPU scheduler acts as the "conductor" of the system, determining which process gains access to the processor and for how long. The fundamental distinction between different scheduling strategies lies in one central question: Does the operating system have the authority to forcibly strip a running process of its CPU control?

Based on this capability, scheduling mechanisms are categorized into two primary paradigms: Non-preemptive Scheduling and Preemptive Scheduling.
Non-preemptive scheduling, often referred to as cooperative scheduling, operates on a principle of voluntary surrender. Once a process is allocated the CPU, it retains control until it reaches a natural stopping point. The process only relinquishes the processor when it:

• Completes its execution.
• Transitions into a waiting state (e.g., requesting I/O operations).
• Explicitly yields control back to the scheduler.

In this model, even if a high-priority or time-sensitive process enters the ready queue, the operating system cannot intervene to interrupt the currently running task.

Common Algorithms

• First-Come, First-Served (FCFS): Processes are executed in the exact order they arrive in the ready queue.
• Non-preemptive Shortest Job First (SJF): When the CPU becomes available, the scheduler selects the process with the smallest estimated burst time.
• Non-preemptive Priority Scheduling: The process with the highest priority is selected at each scheduling point.

Advantages and Disadvantages

The primary benefit of non-preemptive scheduling is its simplicity. Because the OS does not need to interrupt processes, the overhead associated with context switching is significantly lower. However, this comes at the cost of poor responsiveness. A major drawback is the "convoy effect," where a single long-running, CPU-intensive task can block all subsequent short tasks, leading to high average waiting times and system stagnation.

Preemptive Scheduling

Preemptive scheduling is the standard for modern, interactive computing. In this model, the operating system possesses the power to suspend a running process at any time, moving it back to the ready queue to make room for another process. This decision is driven by specific triggers, such as:

• The expiration of a time slice (triggered by a hardware clock interrupt).
• The arrival of a process with a higher priority.
• The arrival of a process with a shorter remaining execution time.

Common Algorithms

• Round Robin (RR): Each process is assigned a fixed time quantum; once the time expires, the process is preempted to allow the next one to run.
• Shortest Remaining Time First (SRTF): A preemptive version of SJF where the CPU is reassigned if a new process arrives with a shorter remaining burst time than the current one.
• Multilevel Feedback Queue (MLFQ): A sophisticated approach that uses multiple queues with different priorities to balance responsiveness and throughput.

Advantages and Disadvantages

Preemptive scheduling offers superior responsiveness and fairness, making it essential for interactive and real-time systems. However, the trade-off is increased system complexity and higher overhead. Frequent context switching—saving the state of one process and loading another—consumes CPU cycles that could otherwise be used for computation. Furthermore, it requires robust hardware support, specifically a programmable timer to trigger interrupts.

Comparative Example

To illustrate the impact of these two methods, consider three processes with the following characteristics:

Scenario A: Non-preemptive SJF

Under non-preemptive SJF, P1 arrives first and takes control of the CPU. Because it cannot be preempted, it runs until completion at $t=8$. At $t=8$, the scheduler looks at the ready queue (P2 and P3) and picks P3 (the shortest job). P3 runs from $t=8$ to $t=10$, followed by P2 from $t=10$ to $t=14$.

• Execution Order: P1 $\rightarrow$ P3 $\rightarrow$ P2
• Average Turnaround Time: $\approx 9.67$

Scenario B: Preemptive SRTF

Under preemptive SRTF, P1 starts at $t=0$. At $t=1$, P2 arrives. Since P2's burst time (4) is shorter than P1's remaining time (7), P1 is preempted. At $t=2$, P3 arrives. Since P3's burst time (2) is shorter than P2's remaining time (3), P2 is preempted.

• Execution Order: P1(0–1) $\rightarrow$ P2(1–2) $\rightarrow$ P3(2–4) $\rightarrow$ P2(4–6) $\rightarrow$ P1(6–14)
• Average Turnaround Time: $7$

The preemptive approach significantly reduces the average turnaround time by ensuring that shorter tasks are not stuck behind long-running ones.

Summary of Core Differences

Real-World Application

Most modern operating systems, including Linux, Windows, and macOS, rely heavily on preemptive scheduling. For instance, the Linux Completely Fair Scheduler (CFS) uses virtual runtime to dynamically decide when to preempt a task to ensure fairness.

Interestingly, we still see "non-preemptive" logic in modern software development through cooperative multitasking models. Technologies like Coroutines in Python/Go or the Event Loop in Node.js operate on the principle that a task must reach an await or a yield point to give up control. While highly efficient for I/O-bound tasks, these models share the same risk as non-preemptive scheduling: a single "greedy" task that fails to yield can freeze the entire execution thread.

Conclusion

The choice between preemptive and non-preemptive scheduling is a fundamental engineering trade-off between efficiency and responsiveness. While non-preemptive scheduling minimizes overhead and is suitable for predictable, batch-oriented workloads, preemptive scheduling is the backbone of the modern computing experience, providing the fluidity and fairness required for interactive multitasking.