How Concurrency Connects to Everything Else

This domain decides which region the lock goes around; OS explains what blocking does to the thread and who wakes it.

OS defines what a race is. Here you find the specific schedule that breaks your invariant.

OS explains what a critical section is; this domain is about picking the smallest one that still holds the invariant.

The loop's mechanics — the phases, the poll, the callback queue — are taught there. Here it is what stalling costs everyone else.

Whether await actually releases the thread depends on which I/O model is underneath.

Oversubscription is expensive because switching is expensive — the register save, the TLB and cache damage are the OS story.

The address-space difference is the OS fact; the design consequence is this domain's subject.

The primitives and their kernel support live there; permits as a capacity limit live here.

The concrete server built around a pool is the OS walkthrough; choosing between models is this domain's decision.

The four conditions and detection algorithms are OS material; here they become a lock-ordering rule you can enforce in review.

Perf teaches how to diagnose contention from signals; this domain teaches why it happens and how to reduce it.

The server-side signal that you are past the limit is a perf topic; choosing the number is a design decision here.

Perf diagnoses it from utilization and traces; this domain classifies it to pick an execution model.

Queueing theory explains why latency explodes before throughput does; backpressure is the design response.

The saturation signal and its arithmetic; pool sizing and the overflow policy are decided here.

The metric that reveals a blocked loop before users notice — the leading indicator for blocking-the-event-loop.

The perf lesson names the incident; single-flight coalescing is the concurrency pattern that prevents it.

Same work, different latency — the waterfall shape that makes the sequential-await trap visible in a trace.

Waiting in front of an idle database is the canonical case of a limit set in the wrong place.

The database solves concurrency for its own data with its own lock manager — and not for your application memory.

Versions and snapshots are how a database implements optimism; the retry loop in your code is the other half.

Read committed does not stop lost updates. Knowing which anomaly the level permits decides whether you need your own control.

Databases detect and abort a victim. Your process does not — which is why lock ordering is prevention, not detection.

What actually happens to two concurrent updates of the same row, at the engine level.

Architecture decides that the work should be asynchronous; this domain runs the queue and bounds it.

Backpressure as an architectural property across services; here it is the bound on one in-process queue.

Cancellation and retry both mean an operation may be attempted more than once, so it had better be safe to repeat.

Whether a call is synchronous is an architecture decision that determines the concurrency model available to you.

What the hardware actually guarantees for a compare-and-swap, and what it costs on the bus.

Independent variables that share a line ping-pong between cores — a hardware effect with a software fix.

Loads and stores are reordered by the compiler and the CPU. The language memory model is the contract on top of this.

Barriers order, they do not flush — the distinction that makes safe publication make sense.

Coherence is what makes shared memory work at all, and coherence traffic is what makes contended atomics slow.

Data parallelism inside a single core, underneath the parallel algorithms this domain decomposes.

On a multi-socket machine, which core touches which memory changes the speedup you get from more threads.

Affinity preserves cache warmth and costs scheduling flexibility — the trade this domain has to make consciously.

Pool sizing starts from a core count, and "16 CPUs" in a container often means neither 16 cores nor 16 anything.

Whether tool calls may overlap is an agent-design question; whether they race on the same resource is this one.

A retried tool call is a second attempt at a side effect — the same problem as a cancelled task that did not stop.

Your per-instance connection limit multiplied by your instance count is the number the database actually sees.

Concurrent shutdown — stop intake, drain with a deadline, cancel the rest — is what makes a rollout not drop requests.

The HTTP contract — ETag, If-Match, 412 — is the API side; the retry loop and its livelock risk are here.

Backpressure across a network boundary, where the queue you cannot see belongs to somebody else.

Fork/join is divide-and-conquer with the subproblems handed to different cores; the recursion is the same.

The canonical case where a sequential-looking dependency turns out to be parallelisable in logarithmic span.