What is Thrashing in Operating Systems?
Learn what thrashing is — excessive page faults, causes, and the working-set model fix — with examples and OS interview questions answered.
Expected Interview Answer
Thrashing is a state where a system spends most of its time swapping pages between RAM and disk rather than executing actual instructions, causing CPU utilization and throughput to collapse even though the system appears extremely busy.
Thrashing happens when the combined working sets of all running processes exceed available physical memory, so almost every memory access triggers a page fault that evicts a page another process needs soon, creating a vicious cycle. As page fault rate rises, the CPU spends increasing time servicing faults instead of running code, so the OS scheduler — seeing low CPU utilization — often makes things worse by admitting more processes, further shrinking each process’s share of memory. The classic fix is the working-set model or page-fault-frequency monitoring: the OS tracks each process’s working set and only runs as many processes as can have their working sets resident simultaneously, suspending or swapping out processes rather than overcommitting memory. Adding more physical RAM, increasing swap efficiency, or reducing the degree of multiprogramming are the practical responses to thrashing.
- Explains a real production failure mode under memory pressure
- Motivates the working-set model for memory management
- Connects page fault rate to CPU utilization and scheduling
- Guides capacity planning — RAM sizing vs number of processes
AI Mentor Explanation
Thrashing is like a groundskeeper constantly swapping the pitch cover on and off because too many overlapping matches are scheduled on one ground: by the time the cover comes off for match A, match B needs it back on, and no actual cricket gets played, only cover-swapping. The fix is scheduling fewer simultaneous matches so each one actually gets uninterrupted playing time — exactly like reducing the degree of multiprogramming to stop thrashing.
Step-by-Step Explanation
Step 1
Overcommitment
Combined working sets of running processes exceed available physical memory.
Step 2
Rising page faults
Nearly every memory access misses, triggering a page fault that must fetch from disk.
Step 3
Eviction cascade
Fetching one page evicts another process’s needed page, causing it to fault soon after.
Step 4
Mitigation
The OS applies the working-set model or reduces multiprogramming, suspending processes to let others fit in memory.
What Interviewer Expects
- A clear definition tying thrashing to excessive page faulting
- Why increasing the number of processes can worsen thrashing
- The working-set model or page-fault-frequency as a mitigation
- Practical fixes: more RAM, fewer concurrent processes, better locality
Common Mistakes
- Confusing thrashing with a normal, occasional page fault
- Thinking adding more processes always increases throughput
- Not knowing the working-set model as a mitigation strategy
- Confusing thrashing with deadlock or starvation
Best Answer (HR Friendly)
“Thrashing is when a computer is so overloaded on memory that it spends nearly all its time swapping data in and out of disk instead of doing real work, so it looks busy but barely makes progress. The fix is to run fewer things at once, or track how much memory each program actually needs, so everything that is running can stay comfortably in memory.”
Code Example
#define FAULT_RATE_HIGH 50 /* faults per second threshold */
void check_thrashing(struct process *p) {
double fault_rate = p->page_faults / p->elapsed_seconds;
if (fault_rate > FAULT_RATE_HIGH) {
/* working set no longer fits in its allotted frames */
suspend_process(p); /* swap it out to free memory for others */
}
}Follow-up Questions
- What is the working-set model and how does it prevent thrashing?
- Why can admitting more processes make thrashing worse?
- How does increasing physical RAM reduce thrashing?
- What is the difference between thrashing and a normal page fault?
MCQ Practice
1. Thrashing is best described as?
Thrashing occurs when excessive page faulting consumes almost all CPU time, leaving little for actual computation.
2. What commonly triggers thrashing?
When the total memory actively needed by all processes is more than what is physically available, thrashing results.
3. Which strategy directly mitigates thrashing?
The working-set model ensures only as many processes run as can have their working sets resident, preventing overcommitment.
Flash Cards
What is thrashing? — A state where the system spends most of its time paging rather than executing useful work.
What causes thrashing? — Combined process working sets exceeding available physical memory.
How does the working-set model help? — It limits how many processes run so each one’s working set stays resident in memory.
What is a quick fix for thrashing? — Reduce the number of concurrently running processes or add more physical RAM.