Build fluency in the vocabulary of two unrelated variables slowing each other down on one shared cache line.
0 / 5 completed
1 / 5
At standup, a dev mentions two threads on different CPU cores each writing to their own separate variable, yet performance is far worse than expected because both variables happen to sit on the same CPU cache line. What is this problem called?
False sharing happens exactly here: two threads write to genuinely separate, unrelated variables, but because those variables happen to sit on the same cache line, every write from one core forces the cache-coherence protocol to invalidate that whole line on the other core, even though the two threads never actually touch each other's data. A deadlock is an unrelated concurrency failure about threads blocking rather than slowing each other down. This is called "false" sharing precisely because the variables aren't logically shared at all, only physically co-located on the same cache line.
2 / 5
During a design review, the team pads a frequently-written-to variable with extra unused bytes so it lands on its own dedicated cache line, away from any other thread's frequently-written variable. Which capability does this padding provide?
This padding provides avoiding false sharing, since giving each thread's frequently-written variable its own dedicated cache line means one thread's write can no longer force an invalidation of the cache line the other thread is reading or writing, because they're no longer physically co-located at all. Leaving the two variables tightly packed together is exactly the layout that causes repeated, needless cache-coherence traffic between the cores. This padding technique is a standard, if slightly memory-wasteful, fix once false sharing has been identified as a real bottleneck.
3 / 5
In a code review, a dev notices a struct holds two counters, each incremented by a different thread on a different core, packed tightly next to each other with no padding at all. What does this represent?
This is a layout at risk of false sharing, since packing two counters tightly together, each incremented by a different thread on a different core, makes it likely they land on the same cache line, so every increment from either thread forces a needless cache-coherence invalidation on the other core. A cache eviction policy is an unrelated concept about discarded cache entries, not CPU cache-line contention. This tight, padding-free packing is exactly the pattern a performance-focused reviewer would flag once two hot, independently-written fields sit this close together in memory.
4 / 5
An incident report shows a multi-threaded counting service scaled far worse than expected as more cores were added, because a profiler traced the bottleneck to two independently-updated per-core counters that happened to sit on the same cache line, forcing constant cache-coherence traffic between cores. What practice would prevent this?
Padding each per-core counter so it occupies its own dedicated cache line removes the needless cache-coherence invalidation traffic between cores, since a write to one counter can no longer force the other core to discard and reload its own copy of a line it never actually shares any real data with. Continuing to pack the counters tightly together with no padding is exactly what caused the poor scaling described in this incident as more cores were added and contention on that one shared line grew. This per-core padding is the standard fix once false sharing has been confirmed as the actual bottleneck by a profiler.
5 / 5
During a PR review, a teammate asks why the team pads hot per-core counters onto separate cache lines instead of just trusting that logically independent variables will never actually interfere with each other's performance. What is the reasoning?
Cache-coherence hardware operates at the granularity of a whole cache line, not an individual variable, so it has no way to know that two variables sharing a line are logically unrelated, and it invalidates the entire line the instant either core writes to any part of it. Two logically independent variables can therefore still contend heavily purely because of how they happen to be laid out in memory, with no actual data dependency between them at all. The tradeoff is the small amount of extra memory padding wastes, which is a cheap price for removing a scaling bottleneck that would otherwise get worse as more cores are added.
What does the "False Sharing Vocabulary" vocabulary exercise cover?
This exercise tests real IT vocabulary related to false sharing vocabulary through 5 multiple-choice questions, each built from realistic workplace sentences rather than abstract definitions.
Is this vocabulary exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is completely free — no account, sign-up, or payment required.
How many questions does this exercise have?
This exercise has 5 questions. Each one shows a real-world sentence or scenario with multiple-choice options and an explanation once you answer.
What happens after I answer a question?
You'll see immediate feedback showing whether your answer was correct, along with a short explanation of why — then a button to move to the next question, and a full results screen at the end.
Can I retry the exercise if I get questions wrong?
Yes. Once you reach the results screen, click "Try again" to reset your answers and go through the exercise from the start as many times as you like.
Do I need to create an account to take this exercise?
No account is needed. Your answers are scored in your browser during the session — nothing is saved to a server, so you can jump straight in.
Is my progress saved if I leave the page?
No — progress within an exercise resets if you navigate away or reload. Each exercise is short enough to complete in a few minutes in one sitting.
Are these vocabulary exercises connected to other topics?
Yes — browse the full vocabulary exercises hub to find related modules covering adjacent IT topics and roles.
How is this different from reading a glossary or blog article?
Exercises like this one are active recall drills — you have to choose the correct term or phrasing yourself, which builds retention faster than passively reading a definition.
Where can I find more vocabulary exercises?
Browse the full Vocabulary exercises hub for hundreds of modules covering Agile, DevOps, security, databases, architecture, and more — organised by IT role and skill.