Post cover image

June 24, 2026

Linux Scheduling Algorithms Explained: Understanding the Completely Fair Scheduler (CFS) (P2)

How Linux actually decides who gets CPU time — made beginner-friendly

By Alwinaji

4 min read

How Linux actually decides who gets CPU time — made beginner-friendly

In Part 1:

We learned:

The Linux scheduler decides what runs next

We explored:

Process lifecycle Context switching Time slicing Preemptive multitasking Why Linux feels responsive

But now comes the deeper question.

Imagine:

You run:

yes > /dev/null

CPU usage:

100%

Then:

You open:

vim

Question:

Why does:

vim

still feel responsive?

Why doesn't:

yes

steal all CPU forever?

How does Linux decide:

Who deserves more CPU time?

How does Linux balance:

Fairness
Responsiveness
Performance

without chaos?

The answer is:

The Linux Scheduler Algorithm

And specifically:

CFS — Completely Fair Scheduler

Today we'll deeply understand:

Why Linux replaced old schedulers What CFS actually is Fair scheduling explained simply vruntime (huge concept) Red-black tree explained visually Nice values (nice, renice) Real-time scheduling basics Hands-on labs Observe scheduling live

And yes —

We'll keep it beginner-friendly.

Let's begin.

First: Why Linux Needed Better Scheduling

Imagine classroom.

Teacher says:

Everyone gets equal speaking time.

Nice.

But problem:

Some students:

Need more attention

Some tasks:

Need faster response

Some:

Can wait

Simple scheduling:

Round-robin

wasn't enough.

Linux needed:

Fair
Responsive
Efficient
Scalable

scheduling.

Thus:

CFS (Completely Fair Scheduler)

was introduced.

Huge Linux innovation.

Old Scheduler Problem

Old Linux schedulers used:

Fixed time slices.

Example:

Process A → 10ms
Process B → 10ms
Process C → 10ms

Simple.

Problem:

Not smart.

Example:

Music app

needs low latency.

Background:

Compression task

can wait.

Treating them equally:

Bad responsiveness

Linux wanted smarter fairness.

What Is CFS?

Simple definition:

CFS tries to give every process a fair share of CPU time.

Key word:

Fair

But fairness does NOT mean:

Exactly equal

Instead:

Linux asks:

Who has gotten the least CPU recently?

Then chooses:

That process.

Beautiful idea.

Restaurant Analogy

Imagine restaurant.

Customers:

Processes

Waiter:

Scheduler

Question:

Who gets served next?

CFS says:

Person who waited longest.

Very fair.

No starvation.

No greedy customer wins forever.

Huge mental model.

The Big Mental Model

CFS tracks:

How much CPU each process already used

Then:

Least CPU used
        ↓
Run first

Visual:

Process A → 20ms used
Process B → 5ms used
Process C → 10ms used
Scheduler picks:
Process B

Why?

Because:

Least CPU recently

Mind blown?

That's Linux fairness.

The Giant Concept: vruntime

This is:

The heart of CFS.

Question:

How does Linux measure fairness?

Using:

Virtual Runtime (vruntime)

Simple definition:

How much CPU time process effectively received

Linux tracks:

CPU usage history

for every process.

Smaller:

vruntime

means:

You ran less recently

So Linux says:

Your turn now.

Huge concept.

Example of vruntime

Imagine:

Firefox → vruntime = 20
VS Code → vruntime = 10
Spotify → vruntime = 5

Scheduler chooses:

Spotify

Why?

Because:

Least CPU recently

Beautiful fairness.

Visual Scheduling Flow

Smallest vruntime
         ↓
Scheduler picks
         ↓
Process runs
         ↓
vruntime increases
         ↓
Process waits

Continuous balancing.

Thousands of times per second.

The Red-Black Tree

Scary name, simple idea

Question:

How does Linux quickly find:

Smallest vruntime

?

Linux uses:

Red-Black Tree

Sounds terrifying.

Reality:

Organized sorting structure.

Think:

Processes sorted by fairness

Linux keeps:

Smallest vruntime

at left side.

Example:

         20
       /    \
      10    30
     /
    5

Scheduler instantly finds:

5

Fast.

Efficient.

Huge performance trick.

Why CFS Is Smart

CFS balances:

Fairness

Nobody starves.

Responsiveness

Interactive apps feel fast.

Throughput

Heavy work still progresses.

Scalability

Works on:

Laptop
Cloud
Servers
Supercomputers

Beautiful engineering.

Hands-On Lab 1 — Observe Scheduling

Run:

top

Observe:

CPU %
PR
NI

Interesting.

You're watching:

Scheduler decisions.

Live.

Nice Values Explained

Question:

Can we tell Linux:

This process matters less

?

Yes.

Using:

Nice values

Range:

-20 → highest priority
19 → lowest priority

Default:

0

Important:

Lower:

nice

means:

Higher priority

Weird Linux naming.

Hands-On Lab 2 — Low Priority Process

Run:

nice -n 10 yes > /dev/null

Meaning:

Less important

Check:

top

Observe:

NI = 10

Linux gives it:

Less CPU preference

Very cool.

Compare Priorities

Open terminal 1:

yes > /dev/null

Terminal 2:

nice -n 15 yes > /dev/null

Observe:

top

Interesting.

Normal process usually gets:

More CPU

Huge realization.

Linux scheduler listens.

Change Priority Live

Find PID:

ps aux | grep yes

Then:

renice 15 PID

Linux updates priority:

Live.

Very useful admin trick.

Process Priority Fields

In:

top

Look for:

PR
NI

Meaning:

PR

Priority.

NI

Nice value.

Example:

PR = 20
NI = 0

Default process.

Why Interactive Apps Feel Fast

Question:

Why:

Typing in terminal

feels instant?

CFS favors:

Interactive tasks

Processes that:

Wake often
Sleep often
Need fast response

Example:

Terminal
Mouse
Keyboard
UI

Linux tries:

Low latency

Huge usability reason.

Real-Time Scheduling

Different world

Some workloads need:

Absolute priority

Examples:

Robotics
Audio
Industrial systems

Linux provides:

FIFO

Run until finished.

Round Robin

Take turns.

Danger:

Bad real-time process:

Can freeze system

Used carefully.

Hands-On Lab 3 — CPU Stress

Install:

sudo apt install stress-ng

Run:

stress-ng --cpu 4

Observe:

top

Watch:

CPU balancing

Linux distributing work.

Very cool.

Stop:

CTRL+C

Observe Scheduler Live

Run:

htop

Press:

F6

Sort:

CPU %

Watch priorities.

Observe:

Processes move dynamically

Scheduler constantly adapting.

Common Beginner Misconceptions

1. "Fair means equal"

No.

Linux balances:

Needs
Priority
Responsiveness

2. "Nice means more CPU"

Wrong.

Higher:

nice

means:

Lower priority

3. "CPU % fixed forever"

Scheduler constantly adjusts.

Dynamic system.

4. "Background tasks never run"

Wrong.

CFS avoids starvation.

Everyone gets chance.

Mini Challenge

Question 1:

What is:

vruntime

?

Question 2:

Why does:

vim

remain responsive?

Question 3:

What does:

nice -n 10

do?

Question 4:

Why does Linux use:

Red-black tree

?

Think deeply.

The Big Mental Model

Linux CFS:

Track CPU usage
        ↓
Calculate vruntime
        ↓
Smallest vruntime wins
        ↓
Process runs
        ↓
Fairness maintained

Beautiful engineering.

Final Thoughts

At first:

CPU scheduling feels magical.

Apps stay responsive.

Background tasks continue.

Everything feels smooth.

But underneath?

Linux is constantly asking:

Who got CPU recently?
Who waited longest?
Who deserves next turn?

And that hidden fairness engine is called:

CFS — Completely Fair Scheduler

And once this clicks…

You stop seeing scheduling as magic.

You finally understand:

How Linux actually shares CPU fairly.