Concurrency & Threading Models

Question 1

What is a race condition?

Accepted Answer

A bug where the program result depends on which thread the OS schedules first — an order that varies non-deterministically at runtime — A race condition occurs when the result of a program depends on which thread happens to run first — an ordering that the OS scheduler decides non-deterministically. Because the bad interleaving may be rare, the bug can pass testing and only appear in production under load.

Question 2

In the unsafe withdrawal demo, the account starts at $100 and two threads each withdraw $10. Why does the final balance end at $90 instead of the correct $80?

Accepted Answer

Both threads read $100 before either writes back, each independently compute $90, and both write $90 — the second write overwrites the first and one $10 withdrawal is lost — This is called a "lost update". Thread 1 reads $100, Thread 2 also reads $100 before Thread 1 has written its result. Both compute $100-$10=$90. Thread 1 writes $90, then Thread 2 also writes $90, completely erasing Thread 1's update. One $10 withdrawal is lost.

Question 3

What does a mutex (mutual exclusion lock) guarantee?

Accepted Answer

That only one thread at a time can execute the protected critical section — any other thread that tries must block until the lock is released — A mutex ensures mutual exclusion: when Thread 1 holds the lock, any other thread that tries to acquire it is forced to wait until Thread 1 releases it. This serialises access to the critical section, preventing simultaneous reads and writes on shared data.

Question 4

What is a "critical section"?

Accepted Answer

A block of code that reads or modifies shared mutable state and must not be executed by more than one thread at a time — A critical section is any block of code that reads or modifies shared data. If two threads enter the critical section simultaneously, a race condition can occur. The mutex protects the critical section by allowing only one thread inside it at a time.

Question 5

What is the key difference between concurrency and parallelism?

Accepted Answer

Concurrency means tasks take turns making progress; parallelism means tasks run at the same instant on separate cores — Concurrency is a program-design property: structuring code so multiple tasks can make progress. On a single core this is achieved by interleaving (context switching). Parallelism requires multiple cores so tasks physically execute at the same moment. You can have concurrency without parallelism (single-core interleaving) but not parallelism without concurrency.

Question 6

What is a deadlock?

Accepted Answer

A state where two or more threads each hold a lock the other needs, so none can proceed and the program halts indefinitely — Deadlock is a circular wait: Thread A holds Lock 1 and waits for Lock 2; Thread B holds Lock 2 and waits for Lock 1. Neither can proceed. Deadlock requires four conditions (mutual exclusion, hold-and-wait, no preemption, circular wait); removing any one prevents it.

Question 7

Why can using locks too aggressively hurt application performance?

Accepted Answer

While a lock is held, every other thread that needs it is blocked and cannot do useful work, so heavy lock contention reduces total throughput — A lock serialises access — by definition only one thread can be inside the critical section at a time. If many threads contend for the same lock, or if the lock is held for a long time, threads spend time waiting rather than doing useful work. This is called lock contention and it limits scalability.

Question 8

In the safe withdrawal demo, what does Thread 2 read as the balance when it eventually acquires the lock?

Accepted Answer

$90 — the balance Thread 1 wrote after finishing its withdrawal, because the mutex forced Thread 2 to wait until Thread 1 released the lock — Because Thread 2 cannot enter the critical section until Thread 1 releases the lock, Thread 2 is guaranteed to see Thread 1's written result of $90. Thread 2 then correctly computes $90-$10=$80. This is exactly what the mutex guarantees: a consistent, up-to-date read.

Question 9

Which of the following is an alternative to using locks for concurrency safety?

Accepted Answer

Atomic operations — CPU instructions that perform a read-modify-write as a single uninterruptible step without acquiring or releasing a lock — Atomic operations (e.g. compare-and-swap) are supported directly by modern CPUs and perform an entire read-modify-write sequence without any other thread being able to interpose. They avoid the overhead of acquiring and releasing a lock and cannot deadlock. Other lock-free approaches include immutable data structures and shared-nothing architectures (e.g. the actor model).

Question 10

A program has 8 concurrent tasks running on a 2-core machine. Which statement best describes its execution?

Accepted Answer

At any instant 2 tasks are physically running — one per core — while the OS rapidly context-switches all 8 across those 2 cores over time — With 8 tasks and 2 cores, 2 tasks run in true parallel at any instant. The OS scheduler rapidly context-switches all 8 tasks onto those 2 cores, giving each time slices. From the outside all 8 appear to make concurrent progress, even though at the hardware level only 2 are physically running at once.

Concurrency or parallelism?

Test your knowledge

What is a race condition?

The short version

Interview Questions

References & Further Reading

Related topics

Love this visualization?