Preemption

A preemptive scheduler can take the CPU away from a running thread without its cooperation. A hardware interrupt, usually a timer tick, transfers control to the kernel no matter what the thread was doing, and the kernel is then free to resume a different thread instead. The alternative is cooperative scheduling, where a switch only happens when the running thread volunteers by yielding or blocking; there, a single thread that never yields owns the CPU forever, and one buggy loop freezes the system.

Preemption turns CPU time into a resource the kernel allocates rather than one threads take. The tick period bounds how long any thread can monopolize a core (its quantum), so an infinite loop degrades into wasted share instead of a hang. The price is paid by every thread: since the tick lands at an arbitrary instruction boundary, code can lose the CPU between any two instructions and must protect its critical sections accordingly, with masked interrupts or atomic instructions.

In the Cosmos kernel every context switch is preemptive today: the switch happens on an interrupt exit (the 10 ms tick, or a device interrupt whose handler woke another thread), and a thread otherwise runs until it parks on a blocking primitive or exits; there is no working voluntary switch. See Preemption and What there is not: a voluntary switch.