Learn Concurrent Programming with Go (James Cutajar)（Z-Library）

【One-Line Pitch】 A practical, example-driven guide that uses Go's lightweight concurrency tools to teach the universal principles of concurrent programming—so you can write faster, more scalable software without drowning in deadlocks and race conditions. Best for developers with basic Go (or C-style language) knowledge who want to move from sequential thinking to confident concurrent design. 【Book Arc】 - **Opening (~0%–10%)**: Frames why concurrency matters—throughput, responsiveness, and taking advantage of multi-core hardware—and lays out the book's three-part structure: foundations, message passing, and advanced topics. - **Early (~10%–30%)**: Builds the mental model: how hardware, the OS, and the Go runtime cooperate; processes vs. threads vs. goroutines; scheduling, run queues, and the crucial distinction between concurrency and parallelism. - **Middle (~30%–55%)**: Dives into memory sharing—shared variables, escape analysis, and the birth of race conditions—then introduces mutexes, readers-writer locks, condition variables, semaphores, waitgroups, and barriers as defenses. - **Late (~55%–80%)**: Shifts to message passing with Go channels and the select statement, showing how channels can be built atop memory-sharing primitives and offering guidance on choosing between the two models. - **Ending (~80%–100%)**: Explores reusable message-passing patterns (pipelining, worker pools), first-class channels, and advanced territory such as atomic variables and futexes, plus exercises that build real tools like recursive file searchers. 【Key Takeaways】 - **Concurrency is a modeling problem, not a syntax problem** (Opening): The book deliberately avoids teaching Go syntax, using the language only to demonstrate transferable principles—so the lessons apply to Java, C++, or any C-style language. - **Amdahl's Law sets a hard ceiling on parallel speedup** (Early): Even with massive processor counts, a small sequential fraction caps your gains—understanding this prevents unrealistic scaling expectations and guides where to optimize. - **Goroutines are cheaper than OS threads** (Early): Managed by the Go runtime with local and global run queues, they consume far fewer resources, making it practical to spawn thousands where threads would be wasteful. - **Race conditions are the central enemy** (Middle): The Stingy/Spendy bank-account example shows how unsynchronized shared memory produces wrong results—recognizing when a race can occur is the second step to good concurrent programming. - **Mutexes, RW locks, and semaphores are layered defenses** (Middle): The book builds these from scratch, showing not just how to use them but how they work—including improving a readers-writer lock with semaphores. - **Message passing eliminates whole classes of errors** (Late): Channels and communicating sequential processes offer an alternative to memory sharing that sidesteps many race conditions, and Go's select statement combines multiple channels elegantly. - **Patterns make concurrency reusable** (Late): Pipelining, worker pools, and message passing become composable building blocks when channels are first-class objects. - **Atomic variables and futexes are the deep end** (Ending): These advanced topics reveal what happens beneath the abstractions—useful for performance-critical work and for understanding the runtime itself. 【Reading Tips】 - **Deep-read Part 1 (Chapters 1–6)**: The memory-sharing foundations—race conditions, mutexes, semaphores—are the conceptual core; skimming here will make later chapters feel like magic tricks. - **Do the exercises**: The book builds progressively harder programs (catfiles → grepfiles → grepdir → grepdirrec); typing them out cements the goroutine mental model far better than reading. - **Skim the OS scheduling details if you're already comfortable**: The run-queue and interrupt walkthroughs are valuable context but can be absorbed quickly if you know operating systems. - **Pay attention to the memory-sharing vs. message-passing guidance in Chapter 8**: This decision framework is the most practically useful takeaway for real projects. - **Treat Chapter 9's patterns as a reference**: Pipelining and worker pools are worth returning to when designing your own systems. 【Coverage Limits】 The excerpts cover the book's structure, early chapters, and selected examples in detail, but the later chapters on advanced patterns and atomic variables are represented only by brief summaries—specific code examples and deeper discussions in those sections are not fully captured here.