Go Concurrency Patterns

What you'll learn

• Explain goroutines, the Go scheduler and the difference between concurrency and parallelism.
• Use buffered, unbuffered, directional and nil channels with select, timers and tickers correctly.
• Choose between channels, sync.WaitGroup, Mutex, Once, atomics and sync.Map for shared state.
• Propagate cancellation and deadlines with context.Context through call chains and goroutines.
• Build pipelines, fan-out/fan-in, worker pools, errgroup tasks, rate limiters and graceful shutdown.
• Find and prevent data races, goroutine leaks and deadlocks, and test concurrent code deterministically.

Syllabus

Concurrency Foundations in Go

1. Concurrency, Parallelism and the Go Scheduler
2. Goroutines and Their Lifecycle
3. Share Memory by Communicating

Channels in Depth

1. Unbuffered vs Buffered Channels
2. Closing Channels, Ranging and nil Channels
3. Directional Channel Types in APIs

select, Timeouts and Timers

1. select Basics and Non-blocking Operations
2. Timeouts, Timers and Tickers
3. The nil-Channel Trick

Synchronisation Primitives

1. sync.WaitGroup
2. Mutex and RWMutex
3. sync.Once, sync/atomic and sync.Map

Context and Cancellation

1. context.Context Basics
2. Propagating Cancellation
3. Context Values and the Rules

Core Concurrency Patterns

1. Pipelines
2. Fan-out and Fan-in
3. Worker Pools and Bounded Concurrency

Errors, Rate Limits and Shutdown

1. errgroup for Concurrent Tasks with Errors
2. Rate Limiting
3. Graceful Shutdown

Correctness in Production

1. Data Races and the Race Detector
2. Goroutine Leaks and Deadlocks
3. Testing Concurrent Code
4. A Go Concurrency Checklist