Implement Go Concurrency Patterns

Covers Go's concurrency primitives - goroutine, channel, select, sync.Mutex, sync.WaitGroup, and context.Context - built around the "don't communicate by sharing memory; share memory by communicating" mantra, and ships seven runnable patterns: a worker pool (a fixed number of goroutines pulling Job values off a channel and pushing Result values onto another, closed once a WaitGroup completes), a fan-out/fan-in pipeline (a generate stage feeding multiple square stages, merged back into one channel), bounded concurrency with a semaphore (both golang.org/x/sync/semaphore.Weighted and a hand-rolled buffered-channel semaphore), graceful shutdown (a Server that starts workers bound to a context, listens for SIGINT and SIGTERM, cancels the context, and waits on a WaitGroup with a timeout before forcing exit), an errgroup with cancellation (golang.org/x/sync/errgroup fetching URLs concurrently, where the first error cancels the rest, plus a SetLimit variant capping concurrent goroutines), a concurrent map (sync.Map for read-heavy workloads versus a hand-built sharded map with per-shard sync.RWMutex for write-heavy workloads), and select patterns (timeout via time.After, non-blocking send and receive via a default case, and priority select nesting a high-priority check before falling back to a combined select). Closes with race detection commands (go test, build, and run with -race) and a do's-and-don'ts list covering context-based cancellation, sender-only channel closing, errgroup for concurrent error handling, buffered channels, goroutine leak prevention, and avoiding time.Sleep for synchronization.

Use it when building concurrent Go applications, implementing worker pools and pipelines, managing goroutine lifecycles, using channels for communication, debugging race conditions, or implementing graceful shutdown. Skip it for anything unrelated to Go concurrency or outside this scope.

Input is a concurrency requirement - parallel job processing, a multi-stage pipeline, rate-limited execution, clean shutdown on signal, concurrent HTTP fetches, or a thread-safe cache; output is the matching runnable Go pattern plus the race-detection command to verify it and the do's-and-don'ts checklist to review it against.

Standard library only for most patterns (sync, context, channels); two patterns pull in golang.org/x/sync (semaphore.Weighted and errgroup). The graceful-shutdown pattern uses os/signal for SIGINT and SIGTERM handling, and the concurrent-map pattern contrasts the standard library's sync.Map against a hand-built sharded map for write-heavy access. References the official Go blog's Concurrency Patterns pipelines post, Effective Go's concurrency section, and Go by Example's goroutines page.

Go developers building concurrent applications who need working worker-pool, pipeline, semaphore, graceful-shutdown, and errgroup code rather than a conceptual overview of goroutines and channels.