What does it mean to say “linux kernel is preemptive”?

Question

I read that Linux kernel is preemptive, which is different from most Unix kernels. So, what does it really mean for a kernal to be preemptive?

Some analogies or exam

Answer 1

I think everyone did a good job of explaining this but I'm just gonna add little more info. in context of Linux IRQ, interrupt and kernel scheduler.

Process scheduler is the component of the OS that is responsible for deciding if current running job/process should continue to run and if not which process should run next.

preemptive scheduler is a scheduler which allows to be interrupted and a running process then can change it's state and then let another process to run (since the current one was interrupted).

On the other hand, non-preemptive scheduler can't take away CPU away from a process (aka cooperative) FYI, the name word "cooperative" can be confusing because the word's meaning does not clearly indicate what scheduler actually does.

For example, Older Windows like 3.1 had cooperative schedulers.

Full credit to wonderful article here

Answer 2

Traditional unix kernels had a single lock, which was held by a thread while kernel code was running. Therefore no other kernel code could interrupt that thread.

This made designing the kernel easier, since you knew that while one thread using kernel resources, no other thread was. Therefore the different threads cannot mess up each others work.

In single processor systems this doesn't cause too many problems.

However in multiprocessor systems, you could have a situation where several threads on different processors or cores all wanted to run kernel code at the same time. This means that depending on the type of workload, you could have lots of processors, but all of them spend most of their time waiting for each other.

In Linux 2.6, the kernel resources were divided up into much smaller units, protected by individual locks, and the kernel code was reviewed to make sure that locks were only held while the corresponding resources were in use. So now different processors only have to wait for each other if they want access to the same resource (for example hardware resource).

Answer 3

I think it became preemptive from 2.6. preemptive means when a new process is ready to run, the cpu will be allocated to the new process, it doesn't need the running process be co-operative and give up the cpu.