Goroutines, channels, and the select statement, then the sync toolkit, context, pipelines and worker pools, goroutine leaks, errgroup, and the memory model — the part of Go everyone comes for, run under the race detector against Go 1.26.
What a goroutine is, why the go keyword makes concurrency almost free, how the runtime multiplexes thousands of them onto a handful of OS threads, and the one rule that trips up everyone: when main returns, the program exits and your goroutines die with it. Compiled and run against Go 1.26.5.
A channel is a typed conduit and a synchronization point at once. Why an unbuffered send blocks until a receiver is ready, the real deadlock fatal error you get when nobody can receive, channel direction types in function signatures, and why a nil channel blocks forever. Compiled and run against Go 1.26.5.
How a buffered channel decouples sender from receiver until the buffer fills, what close actually signals, the panic you get for sending on a closed channel, the comma-ok receive that tells a closed channel from a live one, draining with range, and the rule that only the sender closes. Compiled and run against Go 1.26.5.
The select statement, which blocks until one of several channel operations can proceed and picks a ready one at random. The default clause for non-blocking sends and receives, time.After for timeouts, and the nil-channel trick that disables a branch. Compiled and run against Go 1.26.5.
sync.WaitGroup for waiting on a group of goroutines, why you pass it by pointer and how go vet catches a copy, the loop-variable capture bug that Go 1.22 deleted, and the WaitGroup.Go helper added in Go 1.25. Compiled and run against Go 1.26.5.
What a data race is, why an unsynchronized counter comes out wrong and varies, reading a real WARNING: DATA RACE report from go run -race, and fixing it with sync.Mutex. Why the detector only sees code that runs. Compiled and run against Go 1.26.5.
Three synchronization tools past the plain Mutex — sync.Once for exactly-once setup, the typed sync/atomic values for lock-free counters, and sync.RWMutex for read-heavy state — with when each beats reaching for a full lock. Compiled and run against Go 1.26.5.
The context package — how you cancel and time-bound concurrent work. Roots with Background, WithCancel and WithTimeout, ctx.Done and ctx.Err, why cancelling a parent cancels every child, ctx.Value used sparingly, and the always-defer-cancel rule. Compiled and run against Go 1.26.5.
The pipeline pattern in Go — a generator returns a channel, each stage reads one channel and returns another, and closing propagates down the line. How a single channel preserves order, and the done-channel that stops the whole line without leaking the goroutines behind it. Compiled and run against Go 1.26.5.
Bounding concurrency with a fixed pool of worker goroutines that share a jobs channel, and the close/WaitGroup/range dance that collects their results safely. Why the total is deterministic even when which worker does which job is not, plus fan-in for merging many channels into one. Compiled and run under the race detector against Go 1.26.5.
A goroutine blocked forever on a send or receive that will never complete never returns, leaking its stack and everything it captured — and the race detector will not catch it. Proving leaks with runtime.NumGoroutine, and fixing them with a context escape or a buffer sized so the sender never blocks. Compiled and run under the race detector against Go 1.26.5.
How golang.org/x/sync/errgroup wires a WaitGroup, error propagation, and context cancellation into one small helper: g.Go to launch, g.Wait to collect the first error, an automatically cancelled context so siblings stop, and SetLimit to bound how many run at once. Compiled and run against Go 1.26.5.
How to write a test that actually exercises goroutines, why running the suite under go test -race is the real safety net, and how testing/synctest gives you a fake clock and a deterministic bubble so time-based concurrent code runs instantly instead of flaking. Compiled and run against Go 1.26.5.
The rules that decide when one goroutine is guaranteed to observe another's writes: the happens-before relation, how every synchronization primitive in this series establishes it, why unsynchronized access is undefined rather than merely risky, and why the race detector is the enforcement tool. Compiled and run against Go 1.26.5.