What is a Spinlock?
Learn what a spinlock is, how busy-waiting works, when to use one, and its dangers versus blocking mutexes.
Expected Interview Answer
A spinlock is a locking mechanism where a thread that cannot acquire the lock repeatedly polls it in a tight busy-wait loop instead of yielding the CPU or sleeping, trading wasted CPU cycles for the lowest possible latency to acquire an already-available lock.
Spinlocks are typically implemented on top of an atomic hardware primitive like test-and-set or compare-and-swap: the waiting thread loops, repeatedly attempting the atomic operation until it succeeds, without ever being descheduled by the OS. This avoids the cost of a context switch and being put to sleep and woken up, which makes spinlocks attractive when the expected wait is shorter than the cost of two context switches — a rule of thumb used heavily inside operating system kernels for protecting very short critical sections, such as updating a shared data structure that takes only a few instructions. The major danger is using a spinlock on a single-core system or holding one across a blocking operation: if the thread holding the lock gets preempted or blocks, every other thread spinning on that lock wastes CPU with no progress possible, which is why spinlocks are usually only safe in true multi-core, non-preemptible-critical-section contexts, and why user-space code generally prefers a blocking mutex which can integrate with a spinlock internally but falls back to sleeping under contention.
- Avoids context-switch overhead for very short critical sections
- Lowest possible latency to acquire an already-free lock
- Simple to implement correctly on top of atomic hardware instructions
- Widely used inside OS kernels to protect brief, interrupt-context-safe sections
AI Mentor Explanation
A spinlock is like a substitute fielder standing right at the boundary rope, constantly glancing at the umpire every second to see if they are needed, rather than walking back to the pavilion and waiting to be called. This keeps them ready to sprint on instantly the moment the umpire signals, at the cost of never resting while they wait. If the wait drags on for overs, that constant glancing wastes far more energy than simply sitting down and being summoned when needed.
Step-by-Step Explanation
Step 1
Attempt acquire
Thread calls an atomic primitive (e.g. test-and-set) to try to acquire the lock.
Step 2
Spin on failure
If the lock is already held, the thread loops, repeatedly retrying the same atomic operation.
Step 3
Acquire on success
The moment the atomic operation succeeds, the thread has the lock and enters the critical section.
Step 4
Release
The holder clears the lock variable, letting a spinning thread succeed on its next attempt.
What Interviewer Expects
- A clear definition contrasting spinlocks with blocking/sleeping locks
- When spinlocks make sense (short critical sections, multi-core, kernel contexts)
- Awareness of the danger of holding a spinlock across preemption or blocking
- Understanding that spinlocks waste CPU proportional to wait time
Common Mistakes
- Recommending a spinlock for a long or blocking critical section
- Not knowing spinlocks are dangerous on single-core systems without preemption control
- Confusing a spinlock with a semaphore or a blocking mutex
- Ignoring that spinning wastes real CPU cycles that could run other work
Best Answer (HR Friendly)
“A spinlock is a lock where a thread that cannot get in just keeps checking over and over in a tight loop instead of going to sleep and waiting to be woken up. It is very fast when the wait is short, since there is no overhead of switching tasks, but it wastes CPU time if the wait drags on, so it is really only appropriate for brief operations, often deep inside an operating system kernel.”
Code Example
#include <stdatomic.h>
atomic_int lock_flag = 0;
void spin_acquire(atomic_int *flag) {
int expected;
do {
expected = 0;
} while (!atomic_compare_exchange_weak(flag, &expected, 1));
/* lock acquired */
}
void spin_release(atomic_int *flag) {
atomic_store(flag, 0);
}Follow-up Questions
- When is a spinlock preferred over a blocking mutex?
- Why is holding a spinlock across a blocking call dangerous?
- How do kernels avoid spinlock deadlock with interrupts?
- What is an adaptive mutex and how does it combine spinning and blocking?
MCQ Practice
1. A spinlock differs from a blocking mutex mainly in that it?
A spinlock keeps the waiting thread actively polling rather than being descheduled and woken later by the OS.
2. Spinlocks are best suited for?
When the expected wait is shorter than the cost of a context switch, spinning wastes less time than sleeping and waking.
3. What is a key danger of holding a spinlock while blocking on I/O?
If the lock holder blocks or is preempted, every thread spinning on that lock wastes CPU with zero forward progress.
Flash Cards
What is a spinlock? — A lock where waiting threads busy-wait in a loop instead of sleeping.
Main advantage of a spinlock? — Avoids context-switch overhead when the expected wait is very short.
Main danger of a spinlock? — Wastes CPU if held across preemption or a blocking call, or if contention is high.
Where are spinlocks commonly used? — Inside OS kernels to protect very short, interrupt-context-safe critical sections.