Concurrency & Parallelism

One owner per piece of state, reachable only by message — and what that buys you across a network.

The part you cannot parallelise sets a ceiling — and it is lower than you think.

Indivisible operations in hardware — and the loop that turns one into any update you like.

Waiting for a state, not a lock — and why the check has to be a while loop.

Don't communicate by sharing memory; share memory by communicating.

Four conditions, all required — so breaking any one of them is a complete fix.

One thread, no blocking — and the queue ordering that decides what actually runs next.

Two threads with no shared variable, made slow by sharing 64 bytes.

The relation that decides what one thread is allowed to see of another.

Progress guarantees, and the memory-reclamation problem that makes them hard.

What the hardware and the compiler are allowed to reorder — and why x86 lets bad code pass.

One holder at a time — and why the lost update happens on the line you thought was atomic.

Readers pay nothing at all — and the writer waits for them to leave before freeing anything.

A counter with a queue attached — and why it is not a mutex with extra steps.

Tasks that cannot outlive the block that started them — goto, but for threads.

Reuse the workers, queue the work — and the two questions that decide the size.

What is shared decides everything else — cost, safety, and how a crash spreads.

Idle workers take from the busy — and the end of the deque they take from is the whole trick.