C Concurrency Asynchronous and multithreaded programming (Nir Dobovizki)（Z-Library） (1)

【One-Line Pitch】 A practical, hard-won guide to writing correct and fast concurrent C# code: it explains how async/await and multithreading really work under the hood, when to use each, and how to avoid the bugs that make concurrent code so painful. Best for intermediate C#/.NET developers who already write application code but find async/await and threads confusing or dangerous. 【Book Arc】 - **Opening (~0%–10%)**: Frames the whole problem — what multithreading and asynchronous programming actually are, why multicore CPUs and cloud economics make them essential, and how the compiler rewrites your code (lambdas, yield return) before async/await enters the picture. - **Early (~10%–30%)**: Builds the async/await foundation — Task and Task<T>, how await suspends and resumes, async void, ValueTask — then moves into multithreading basics: threads, the thread pool, Task.Run, shared data, locks, and deadlocks. - **Middle (~30%–55%)**: Connects the two worlds — where code runs after await, locks inside async code, UI threads, and the real trade-offs of async/await (it is contagious, edge-case-heavy, and not free). Also catalogs classic pitfalls: partial updates, memory reordering, deadlocks, race conditions, starvation. - **Late (~55%–80%)**: Advanced practice — processing sequences in the background (Parallel, work queues, BlockingCollection), cancellation with CancellationToken and timeouts, awaiting your own events via TaskCompletionSource, controlling which thread continuations run on (ConfigureAwait, Task.Yield, schedulers), and handling exceptions in async code. - **Ending (~80%–100%)**: Thread-safe collections and building your own asynchronous collection-like components, rounding out the toolkit for real production concurrency. 【Key Takeaways】 - **Multithreading and async solve different problems** (Early): multithreading lets a computer appear to do many things at once; async keeps the CPU productive during waits. Combining them is what lets servers handle thousands of clients. - **Async/await is widely used but poorly understood** (Early): the author's interviews and consulting experience show most developers cannot explain how it works — this book treats that gap as the root cause of production bugs. - **Concurrency has a real cost, so know when not to use it** (Middle): async is contagious, has more edge cases, and is expensive; the book repeatedly stresses choosing concurrency deliberately rather than by default. - **Classic pitfalls are predictable and avoidable** (Middle): partial updates, memory access reordering, deadlocks, race conditions, and starvation each get concrete avoidance strategies rather than vague warnings. - **Cancellation and timeouts are first-class design concerns** (Late): CancellationToken, exception-based cancellation, callbacks, and combined cancellation methods are presented as standard building blocks for background work. - **You can await your own events** (Late): TaskCompletionSource lets you adapt old APIs, wait for initialization, and build asynchronous data structures — extending async beyond built-in operations. - **Thread placement after await is controllable** (Late): synchronization contexts, ConfigureAwait(false), Task.Yield, and task schedulers determine where continuations run, which matters especially for UI apps. - **Exceptions behave differently in async code** (Late): AggregateException handling, lost exceptions, and async void methods are called out as debugging traps worth studying carefully. 【Reading Tips】 - Read Part 1 (chapters 1–7) carefully if you are shaky on async/await internals; the pizza-and-web-server analogy in chapter 1 is the conceptual anchor for everything later. - Skim the compiler-rewriting chapter if you already understand lambdas and yield return, but do not skip the async/await mechanics chapter — it is the book's core. - Treat the pitfalls chapter as a checklist to revisit when debugging real concurrency bugs rather than memorizing it in one pass. - Deep-read the chapters on cancellation, TaskCompletionSource, and ConfigureAwait when you start writing production background services or UI code. - Keep the code samples (available via liveBook and the author's GitHub) open alongside the text; the book is explicitly example-driven. 【Coverage Limits】 This guide is based on stratified excerpts covering the front matter, table of contents, and early chapters; detailed content of later chapters (thread-safe collections, custom async collections) is inferred from chapter titles and may not reflect the full depth of the book.