What's the difference between preemptive and cooperative scheduling?

In preemptive scheduling the kernel can forcibly take the CPU away from a running task at any point, typically the moment a higher-priority task becomes Ready (or, among equals, when a time slice expires), so a running task can be interrupted mid-function and switched out. In cooperative scheduling the running task keeps the CPU until it voluntarily gives it up by blocking or explicitly yielding; the kernel never forcibly preempts. The tradeoff is responsiveness versus simplicity. Preemptive guarantees an urgent task runs within a context switch regardless of what was running, which is essential for meeting tight deadlines, but it means any data shared between tasks can be interrupted mid-update, so you need mutexes/critical sections. Cooperative makes shared data implicitly safe between yield points (a task can't be interrupted by another task while it isn't yielding), simplifying synchronization, but it's only as responsive as the worst-behaved task, one task that fails to yield hangs the entire system, and no high-priority task can preempt to meet a deadline. So preemptive is the default for real-time responsiveness; cooperative is a disciplined, simpler model viable only when you trust every task's yield behavior.