Post cover image

June 24, 2026

How the Linux Scheduler Actually Works: How Your CPU Decides What Runs Next (P1)

A beginner-friendly but deep dive into the hidden Linux system that makes multitasking possible

By Alwinaji

4 min read

A beginner-friendly but deep dive into the hidden Linux system that makes multitasking possible

You open:

firefox

Spotify is playing.

VS Code is open.

Terminal running:

docker compose up

Chrome has:

17 tabs

YouTube playing video.

Background updates running.

Question:

How does your computer not explode?

You only have:

One CPU_ (or a few CPU cores)_

But Linux appears to run:

Hundreds of programs

at the same time.

Feels magical.

Question:

How does Linux decide:

What runs next?

Why does:

vim

feel responsive,

while:

yes > /dev/null

doesn't freeze your machine?

How does Linux prevent:

One greedy process

from stealing everything?

The answer is:

The Linux Scheduler

Today we'll deeply understand:

Why schedulers exist What problem schedulers solve Process lifecycle explained simply Context switching Time slicing Preemptive multitasking CPU scheduling goals Hands-on Linux labs Observe scheduling live

And yes —

We'll keep it beginner-friendly.

Let's begin.

First: The Problem

Imagine:

You own:

1 chef

But restaurant has:

100 customers

Question:

Who gets served first?

What if one customer says:

"I need ALL attention forever."

Restaurant breaks.

Chaos.

This is exactly:

CPU scheduling problem.

Your CPU is:

Chef

Programs are:

Customers

Linux scheduler is:

Restaurant manager

deciding:

Who gets CPU time
When
For how long

Huge realization:

Your CPU can only execute one instruction per core at a time.

Everything else is:

Illusion.

What Is a Scheduler?

Simple definition:

A scheduler decides which process gets CPU time next.

Very important wording:

CPU time

Because CPU is limited.

Question:

How can Linux run:

Firefox
Spotify
VS Code
Terminal
Kernel tasks

simultaneously?

Answer:

Linux rapidly switches between them.

Extremely fast.

Feels parallel.

Actually:

Controlled switching.

The Big Mental Model

Without scheduler:

Process A starts
      ↓
Never stops
      ↓
Everything else frozen

Terrible.

With scheduler:

Process A
      ↓
Process B
      ↓
Process C
      ↓
Process A
      ↓
Process D

Happens:

Thousands of times per second.

Feels like:

Everything running together

But really:

Tiny CPU turns.

CPU Time Is Shared

Question:

What happens when:

yes > /dev/null

runs?

This command:

Never stops
Consumes CPU forever

Without scheduler:

Entire system freezes

Bad.

Linux instead says:

You get small CPU slice.
Then wait.

Very important concept.

Process States Explained

Linux processes move between:

Different states.

Think:

Queue at airport.

1. Running

Currently using CPU

Example:

Firefox rendering webpage

State:

RUNNING

Only:

One process per CPU core

can be here.

Important realization.

2. Ready (Runnable)

Waiting for CPU

Example:

VS Code wants CPU

but CPU busy.

Linux says:

Wait your turn.

State:

READY

Very common.

3. Sleeping

Waiting for something

Example:

Browser waiting for:

Network response

Or:

sleep 10

Process intentionally idle.

State:

SLEEPING

Not consuming CPU.

Huge misconception beginners have:

Sleeping ≠ dead.

4. Zombie

Finished but not cleaned up

Strange Linux concept.

Process exited.

But parent didn't:

Collect exit status

Result:

Zombie process

We'll cover deeply later.

Visual Process Lifecycle

waiting for CPU
                 ↑
                 |
RUNNING → READY → RUNNING
    ↓
SLEEPING
    ↓
READY

Linux constantly moves processes.

Very dynamic system.

Hands-On Lab 1 — Observe Processes

Run:

top

Observe:

PID
CPU %
MEM %
STATE

Interesting.

Press:

Shift + P

Sort by CPU.

Question:

Who is consuming CPU right now?

You're watching:

Scheduler decisions live.

Context Switching Explained

Question:

How does Linux jump between programs?

Example:

CPU currently running:

Firefox

Suddenly:

User moves mouse.

Linux decides:

Terminal should run

Question:

How does CPU remember:

Firefox progress?

Answer:

Context switching.

What Is Context?

Context means:

CPU state

Things like:

Registers
Program counter
Stack pointer
Memory state

Linux saves:

Process A state

Then loads:

Process B state

CPU continues.

Feels magical.

Actually:

State saving.

Visual Context Switch

Firefox running
      ↓ interrupt
Save state
      ↓
Load terminal state
      ↓
Terminal running

Then later:

Save terminal
      ↓
Restore Firefox

Huge Linux concept.

Why Context Switching Is Expensive

Question:

Why not switch constantly?

Because:

Switching costs work.

Linux must:

Save registers
Save execution state
Load new process state
Invalidate caches

Too many switches:

Performance drops

Scheduler balances:

Responsiveness
vs
Efficiency

Beautiful engineering.

Time Slicing

How Linux shares CPU fairly

Question:

How long should process run?

Forever?

No.

Linux gives:

Small CPU window.

Called:

Time slice (quantum)

Example:

10 milliseconds

Then:

Next process

CPU rotates.

Visual Time Slicing

CPU Timeline

Firefox → VSCode → Terminal
   5ms        5ms       5ms

Feels simultaneous.

Reality:

Tiny slices.

Mind blown?

Preemptive Multitasking

Very important concept.

Old systems:

Process voluntarily gives CPU

Problem:

Bad process says:

No.

System freezes.

Linux instead:

Forces process to stop

Example:

Time slice over.

Linux interrupts:

Enough.
Your turn ended.

This is called:

Preemptive multitasking

Huge reason Linux feels responsive.

Hands-On Lab 2 — Create CPU Hog

Run:

yes > /dev/null

CPU usage spikes.

Open another terminal:

top

Interesting:

Machine still usable.

Question:

Why?

Scheduler.

Linux says:

You get CPU,
but not forever.

Press:

CTRL + C

to stop.

Observe Scheduling Live

Run:

htop

Install if missing:

sudo apt install htop

Observe:

CPU bars moving.

Processes jumping.

Why?

Scheduler constantly reshuffling.

Very cool.

What Makes Good Scheduling?

Linux scheduler tries to optimize:

1. Fairness

No process should starve.

Example:

Bad:

Chrome gets everything
Terminal frozen

Good:

Everyone gets turns

2. Responsiveness

Typing should feel instant.

Example:

You press:

A

Screen updates immediately.

Linux prioritizes:

Interactive tasks

3. Throughput

Complete lots of work.

Example:

Servers handling:

Thousands of requests

Need efficiency.

4. Low Latency

Fast reaction time.

Important for:

Games
Audio
Real-time systems

Hands-On Lab 3 — Observe Scheduling Fairness

Open terminal 1:

Run:

yes > /dev/null

Open terminal 2:

Run again:

yes > /dev/null

Now:

top

Observe:

CPU split.

Example:

50%
50%

Huge realization:

Scheduler sharing CPU.

Nice Values (Preview)

Question:

Can Linux prefer some programs?

Yes.

Example:

nice -n 10 yes > /dev/null

Means:

Lower priority

We'll deeply cover this in:

Part 2 (CFS Scheduler)

Multi-Core CPUs

Question:

What if:

4 cores

exist?

Linux can run:

4 processes simultaneously

One per core.

Scheduler balances work across CPUs.

Very clever.

Common Beginner Misconceptions

1. "Everything runs at same time"

Not exactly.

Reality:

Rapid switching

2. "One app uses entire CPU"

Scheduler prevents abuse.

3. "Sleeping process uses CPU"

No.

Sleeping means:

Waiting

4. "CPU = infinite"

No.

Scheduler carefully shares limited resource.

Mini Challenge

Question 1:

Why doesn't:

yes > /dev/null

freeze Linux?

Question 2:

What is:

Context switching?

Question 3:

What is:

Time slicing

?

Question 4:

Why is preemption important?

Think deeply.

The Big Mental Model

Linux scheduler:

Many processes
        ↓
CPU competition
        ↓
Scheduler decisions
        ↓
Tiny CPU slices
        ↓
Feels simultaneous

Beautiful engineering.

Final Thoughts

At first:

Multitasking feels magical.

Browser.

Music.

Terminal.

Docker.

Everything running together.

Feels impossible.

But underneath?

Linux is doing something incredibly smart.

Rapidly deciding:

Who runs next
How long
When to stop

thousands of times every second.

And that hidden system is called:

The Linux Scheduler

And once this clicks…

You stop seeing multitasking as magic.

You finally understand:

How Linux decides what runs next.