Go Concurrency, demystified

Concurrency is structure (independent activities); parallelism is simultaneous execution. CSP, GOMAXPROCS, channels vs mutexes, and Amdahl's law.

What a data race is, why i++ isn't atomic, why time.Sleep never fixes it, the race detector, and the three real fixes: mutex, channel, atomic.

The three ways concurrent programs stop making progress — the Coffman conditions, Go's deadlock detector and its limits, lock ordering, and fixes.

Go's lightweight, runtime-scheduled concurrent functions — the fork-join model, their tiny cost, M:N scheduling, and how to avoid leaks.

Typed conduits that synchronize goroutines — direction, buffering, ownership, closing, and the axioms table that explains every behavior.

Wait on multiple channel operations at once — the basis of timeouts, cancellation, non-blocking I/O, fan-in, and the event loop.

Mutex, RWMutex, WaitGroup, Once, Cond and Pool — the lower-level primitives for guarding shared state, plus the copylocks rule and mutex-vs-channel guidance.

Lock-free single-word operations — the typed atomic.Int64/Bool/Pointer, when atomics beat a mutex, compare-and-swap loops, and snapshot swaps.

Happens-before — the rules that decide when one goroutine is guaranteed to see another goroutine's writes.

Propagating cancellation, deadlines and request-scoped values across API boundaries — the four constructors and the conventions that keep it sane.

Control how fast work happens — the token-bucket algorithm, a ticker limiter, channel semaphores for concurrency, golang.org/x/time/rate, and backpressure.

A goroutine can't return an error to its caller — propagate failures with the Result pattern, first-error cancellation, errgroup, and per-goroutine recover.

The M:N scheduler — G/M/P, local and global run queues, work-stealing, syscall handoff, the netpoller, preemption, and GOMAXPROCS.

The concurrent tri-color GC, write barrier, GOGC and GOMEMLIMIT, growable goroutine stacks, escape analysis, and sync.Pool.

Process a stream of data through a series of stages connected by channels, where each stage is a goroutine.

Distribute work across multiple goroutines (fan-out) and merge their results back into one stream (fan-in).

Bound concurrency by feeding jobs to a fixed number of long-lived worker goroutines.

Produce a stream of values from a goroutine over a channel, lazily and on demand.

Wrap a value stream so that ranging over it also stops cleanly the moment a cancellation signal fires.

Propagate cancellation, deadlines, and request-scoped values across API boundaries and goroutine trees with context.Context.

Limit how many goroutines may run a section of code (or hold a resource) at the same time.

Run a group of goroutines, wait for them all, capture the first error, and cancel the rest automatically.

Broadcast events to many dynamic subscribers through a broker, decoupling producers from consumers.