Mastering Multithreading with Go Course

Lesson 1 • Goroutine Synchronisation with WaitGroups

Use sync.WaitGroup to coordinate goroutine completion without busy-waiting. Provides the first practical synchronisation tool before channels are introduced.

Lesson 2 • Understanding Race Conditions

Identify data races through examples and the Go race detector tool. Sets the problem context that motivates all synchronisation mechanisms taught later.

Lesson 3 • Go Runtime and Scheduler Internals

Examine the M:N threading model and the Go scheduler's work-stealing algorithm. Establishes the runtime foundation every subsequent concurrency pattern depends on.

Lesson 1 • Range Over Channels and Done Signals

Iterate over channel output with range and signal termination via done channels. Establishes clean shutdown patterns reused in pipeline and worker-pool chapters.

Lesson 2 • Directional Channel Types

Restrict channel direction using send-only and receive-only type annotations to enforce API contracts. Improves code safety and documents intent in concurrent APIs.

Lesson 3 • Select Statement and Multiplexing

Use select to wait on multiple channel operations simultaneously and implement timeouts. Unlocks fan-in patterns and responsive concurrent control flows.

Lesson 4 • Buffered vs. Unbuffered Channels

Contrast synchronous unbuffered channels with asynchronous buffered channels and their capacity semantics. Enables correct channel sizing decisions in later pipeline designs.

Lesson 1 • Go Memory Model Essentials

Interpret Go's formal memory model guarantees for synchronisation operations. Prevents subtle bugs caused by compiler and CPU reordering in concurrent code.

Lesson 2 • sync.Once and Lazy Initialisation

Guarantee single execution of initialisation code across concurrent goroutines with sync.Once. Solves the singleton initialisation problem safely in concurrent programs.

Lesson 3 • sync.Mutex and sync.RWMutex

Lock and unlock shared resources with Mutex and optimise read-heavy workloads with RWMutex. Provides the foundational shared-state protection tool for the chapter.

Lesson 4 • Atomic Operations with sync/atomic

Perform lock-free reads and writes on primitive types using the sync/atomic package. Enables high-performance counters and flags without mutex overhead.

Lesson 1 • Cancellation with WithCancel

Propagate cancellation signals through goroutine trees using WithCancel and CancelFunc. Enables clean goroutine shutdown triggered by parent decisions.

Lesson 2 • Context in HTTP and gRPC Handlers

Apply context cancellation and deadlines inside HTTP and gRPC server handlers. Demonstrates real-world integration patterns that reinforce all prior context concepts.

Lesson 3 • Deadlines and Timeouts

Bound operation duration with WithDeadline and WithTimeout to prevent indefinite blocking. Directly applicable to network calls, database queries, and RPC handlers.

Lesson 4 • Storing and Retrieving Values in Context

Attach request-scoped values to context using WithValue and retrieve them safely. Covers correct key typing to avoid collisions in large codebases.

Lesson 1 • Fan-In: Merging Results

Merge multiple output channels into one using goroutines and select for result aggregation. Completes the fan-out/fan-in pattern for parallel workload collection.

Lesson 2 • Fan-Out: Distributing Work

Distribute a single input channel across multiple worker goroutines to parallelise processing. Builds on pipeline fundamentals to exploit multi-core hardware.

Lesson 3 • Rate Limiting in Pipelines

Apply token-bucket and ticker-based rate limiting within pipeline stages to control throughput. Prevents downstream overload in production data-processing systems.

Lesson 4 • Generator Pattern

Produce streams of values from goroutines using the generator idiom for lazy evaluation. Enables memory-efficient data sourcing for pipeline stages.

Lesson 1 • Dynamic Pool Sizing

Adjust worker count at runtime based on queue depth and system load metrics. Extends the static pool to handle variable workloads without over-provisioning.

Lesson 2 • Priority Task Queues

Implement priority-ordered job dispatch using heap-based queues with mutex protection. Enables differentiated service levels within a single worker pool.

Lesson 3 • Error Handling in Worker Pools

Collect, aggregate, and surface errors from concurrent workers without losing results. Ensures pool reliability and observability required in production environments.

Lesson 4 • Persistent and Durable Task Queues

Connect worker pools to external message brokers for durable, at-least-once job delivery. Bridges in-process concurrency with distributed task processing architectures.

Lesson 1 • Deadlock Detection and Prevention

Recognise deadlock patterns through lock-ordering analysis and Go's built-in deadlock detector. Provides prevention strategies applicable to all mutex and channel usage.

Lesson 2 • Livelock and Starvation

Distinguish livelock from deadlock and identify starvation in goroutine scheduling. Equips students to resolve subtle progress failures invisible to the race detector.

Lesson 3 • Goroutine Leak Detection

Find and eliminate goroutines that never terminate using runtime metrics and goleak. Prevents memory and CPU exhaustion in long-running services.

Lesson 4 • Advanced Race Detector Usage

Integrate the race detector into CI pipelines and interpret complex race reports. Moves beyond basic detection to systematic race elimination in large codebases.

Lesson 1 • Lock-Free Data Structures

Build lock-free stacks and queues using compare-and-swap atomic primitives. Provides high-throughput alternatives to mutex-protected structures for specific workloads.

Lesson 2 • GOMAXPROCS and Scheduler Tuning

Tune GOMAXPROCS and goroutine counts to match hardware topology and workload type. Translates scheduler knowledge from Chapter 1 into measurable performance gains.

Lesson 3 • Benchmarking Concurrent Code

Write reliable concurrent benchmarks using testing.B and avoid common measurement pitfalls. Ensures performance claims are reproducible and statistically meaningful.

Lesson 4 • Reducing Lock Contention

Apply sharding, local caching, and fine-grained locking to minimise mutex contention. Directly improves throughput in high-concurrency services measured in earlier profiling.