| Adding More Stages |
03. Pipeline Pattern |
| Atomic Types (Go 1.19+) |
09. sync & atomic Primitives |
| Atomic vs Mutex |
09. sync & atomic Primitives |
| Basic Pipeline |
03. Pipeline Pattern |
| Basic Worker Pool |
05. Worker Pools |
| Buffered Channels |
01. Concurrency Refresher |
| Buffered vs Unbuffered Job Channel |
05. Worker Pools |
| Burst Rate Limiting |
06. Rate Limiting & Throttling |
| Channel Direction |
01. Concurrency Refresher |
| Channel Patterns |
14. Concurrency Cheat Sheet |
| Channel-Based Semaphore |
07. Semaphore & Bounded Concurrency |
| Channel-Based Solution |
11. Classic Problems |
| Channels |
01. Concurrency Refresher |
| Channels vs Mutexes vs Atomics |
01. Concurrency Refresher |
| Channels: Unbuffered vs Buffered |
14. Concurrency Cheat Sheet |
| Checking the Deadline |
02. Context Deep Dive |
| Choosing the Right Pattern |
14. Concurrency Cheat Sheet |
| Classic Deadlock: Unbuffered Channel |
10. Deadlocks & Race Conditions |
| Classic Problems |
14. Concurrency Cheat Sheet |
| Closing Channels |
01. Concurrency Refresher |
| Collecting All Errors |
08. Error Handling in Concurrent Code |
| Common Race Conditions |
10. Deadlocks & Race Conditions |
| Compare-And-Swap (CAS) |
09. sync & atomic Primitives |
| Concepts & Patterns at a Glance |
14. Concurrency Cheat Sheet |
| Concurrency Control |
14. Concurrency Cheat Sheet |
| Concurrency Control Comparison |
14. Concurrency Cheat Sheet |
| Context Propagation |
02. Context Deep Dive |
| context.Background and context.TODO |
02. Context Deep Dive |
| context.WithCancel |
02. Context Deep Dive |
| context.WithDeadline |
02. Context Deep Dive |
| context.WithTimeout |
02. Context Deep Dive |
| context.WithValue |
02. Context Deep Dive |
| Coordinator |
13. Build: Concurrent Web Scraper |
| Core Patterns |
14. Concurrency Cheat Sheet |
| Daisy Chain |
12. Channel Patterns |
| Deadlock |
10. Deadlocks & Race Conditions |
| Deadlock: Lock Ordering |
10. Deadlocks & Race Conditions |
| Deadlock: Two Goroutines Waiting on Each Other |
10. Deadlocks & Race Conditions |
| Debugging Techniques |
10. Deadlocks & Race Conditions |
| Dijkstra's Solution: Ordered Locking |
11. Classic Problems |
| Dynamic Rate Adjustment |
06. Rate Limiting & Throttling |
| Dynamic Worker Count |
04. Fan-Out / Fan-In |
| errgroup |
08. Error Handling in Concurrent Code |
| errgroup with Concurrency Limit |
08. Error Handling in Concurrent Code |
| Error Channels |
08. Error Handling in Concurrent Code |
| Error Handling in Concurrent Code |
14. Concurrency Cheat Sheet |
| Fan-In |
04. Fan-Out / Fan-In |
| Fan-Out |
04. Fan-Out / Fan-In |
| Fan-Out / Fan-In Combined |
04. Fan-Out / Fan-In |
| Fan-Out vs Worker Pool |
04. Fan-Out / Fan-In |
| Fetcher |
13. Build: Concurrent Web Scraper |
| First Error Wins |
08. Error Handling in Concurrent Code |
| golang.org/x/time/rate |
06. Rate Limiting & Throttling |
| Goroutine Dump |
10. Deadlocks & Race Conditions |
| Goroutines |
01. Concurrency Refresher |
| Graceful Shutdown |
05. Worker Pools |
| Improvements to Try |
13. Build: Concurrent Web Scraper |
| Lifecycle Management |
14. Concurrency Cheat Sheet |
| Loop Variable Capture |
10. Deadlocks & Race Conditions |
| Main |
13. Build: Concurrent Web Scraper |
| Map Concurrent Access |
10. Deadlocks & Race Conditions |
| Multiple Producers, Multiple Consumers |
11. Classic Problems |
| Mutex |
01. Concurrency Refresher |
| Naive Implementation (Deadlocks) |
11. Classic Problems |
| Non-Blocking Rate Limiting |
06. Rate Limiting & Throttling |
| Ordered Results |
04. Fan-Out / Fan-In |
| Panic Recovery in Goroutines |
08. Error Handling in Concurrent Code |
| Patterns in the Real World |
11. Classic Problems |
| Patterns Used |
13. Build: Concurrent Web Scraper |
| Per-Worker vs Shared Limiter |
06. Rate Limiting & Throttling |
| Ping-Pong |
12. Channel Patterns |
| Pipeline with Context |
03. Pipeline Pattern |
| pprof for Goroutine Leaks |
10. Deadlocks & Race Conditions |
| Practical Example: Bounded File Processing |
07. Semaphore & Bounded Concurrency |
| Practical Example: Concurrent URL Fetcher |
05. Worker Pools |
| Practical Example: Log Processing |
03. Pipeline Pattern |
| Preventing Deadlocks |
10. Deadlocks & Race Conditions |
| Prevention Checklist |
10. Deadlocks & Race Conditions |
| Producer-Consumer |
11. Classic Problems |
| Producer-Consumer with Context |
11. Classic Problems |
| Project Setup |
13. Build: Concurrent Web Scraper |
| Quick Reference |
09. sync & atomic Primitives |
| Quit Signal |
12. Channel Patterns |
| Race Conditions |
10. Deadlocks & Race Conditions |
| Race Detector |
10. Deadlocks & Race Conditions |
| Rate Limiting Workers |
06. Rate Limiting & Throttling |
| Real-World Pattern: HTTP Handler |
02. Context Deep Dive |
| Real-World Pattern: Worker with Context |
02. Context Deep Dive |
| Restore Sequence |
12. Channel Patterns |
| Ring Buffer Channel |
12. Channel Patterns |
| Running It |
13. Build: Concurrent Web Scraper |
| Select |
01. Concurrency Refresher |
| Semaphore with Context |
07. Semaphore & Bounded Concurrency |
| Simple Rate Limiting with time.Ticker |
06. Rate Limiting & Throttling |
| Single Producer, Single Consumer |
11. Classic Problems |
| singleflight |
09. sync & atomic Primitives |
| Slice Append |
10. Deadlocks & Race Conditions |
| Struct-Based Worker Pool |
05. Worker Pools |
| Subscription Pattern |
12. Channel Patterns |
| sync Primitives Quick Reference |
14. Concurrency Cheat Sheet |
| sync.Cond |
09. sync & atomic Primitives |
| sync.Map |
09. sync & atomic Primitives |
| sync.Once |
09. sync & atomic Primitives |
| sync.Pool |
09. sync & atomic Primitives |
| sync.RWMutex |
09. sync & atomic Primitives |
| sync/atomic |
09. sync & atomic Primitives |
| The Dining Philosophers |
11. Classic Problems |
| The Race Detector |
10. Deadlocks & Race Conditions |
| Throttling with time.Ticker in Pipelines |
06. Rate Limiting & Throttling |
| Unbuffered vs Buffered: When to Use Which |
01. Concurrency Refresher |
| URL Extraction |
13. Build: Concurrent Web Scraper |
| Visited Tracker |
13. Build: Concurrent Web Scraper |
| WaitGroup |
01. Concurrency Refresher |
| Weighted Semaphore |
07. Semaphore & Bounded Concurrency |
| What's Next |
01. Concurrency Refresher |
| When to Use Pipelines |
03. Pipeline Pattern |
| Worker Pool with Context |
05. Worker Pools |
| Worker Pool with Rate Limiting |
13. Build: Concurrent Web Scraper |