Java 并发编程实站(Java Concurrency in Practice) ([美]Brian Goetz，等 童云兰，等)（Z-Library）

【One-Line Pitch】 A rigorous, practice-first guide to writing correct and performant multithreaded Java, aimed at developers who already know the language and now need to reason about safety, liveness, and scalability under real concurrency. 【Book Arc】 - **Opening (~0%–15%)**: Establishes why concurrency is hard — threads as a double-edged sword, the risks of shared mutable state, and the mental model of safety versus liveness that frames everything later. - **Early (~15%–35%)**: Builds the correctness foundation — atomicity, visibility, ordering, and the Java Memory Model, plus the core building blocks (synchronization, volatile, confinement) that make objects safely publishable. - **Middle (~35%–60%)**: Moves from primitives to composition — designing thread-safe classes, delegating and documenting thread safety, and using the standard concurrent collections and synchronizers instead of hand-rolled locks. - **Late (~60%–80%)**: Shifts to structure and throughput — task execution, thread pools, cancellation and shutdown, and the trade-offs between responsiveness and resource consumption. - **Ending (~80%–100%)**: Addresses performance and testing — scalability bottlenecks, avoiding liveness hazards like deadlock, and strategies for testing concurrent code that is inherently nondeterministic. 【Key Takeaways】 - **Concurrency is fundamentally about managing shared mutable state** (Opening): the book's central framing is that most bugs come from uncontrolled access to state, not from threads themselves, so design decisions about ownership and confinement matter more than API knowledge. - **Safety and liveness are separate, sometimes competing goals** (Early): correctness (nothing bad happens) and progress (something good eventually happens) require different techniques, and optimizing one can undermine the other. - **The Java Memory Model explains visibility and ordering** (Early): without understanding happens-before relationships, developers misdiagnose stale reads and reordering as "random" bugs; this is the conceptual backbone of the book. - **Prefer existing thread-safe building blocks over custom synchronization** (Middle): the concurrent collections and synchronizers encode hard-won correctness, and reinventing them usually introduces subtle failures. - **Thread safety must be documented as part of a class's contract** (Middle): callers cannot use a class correctly unless its concurrency guarantees — or lack thereof — are explicit. - **Task execution should be decoupled from thread management** (Late): structuring work as tasks and letting executors handle scheduling improves flexibility, resource control, and shutdown behavior. - **Cancellation and shutdown are first-class design concerns** (Late): interruption policy and cooperative cancellation must be planned, not patched in after threads refuse to stop. - **Performance work should target scalability, not micro-optimization** (Ending): the real question is how throughput behaves as cores and load increase, and testing concurrent code requires deliberate, repeatable stress strategies. 【Reading Tips】 - Read the early chapters on atomicity, visibility, and the memory model slowly — they are the load-bearing concepts; skimming them makes later chapters feel like disconnected recipes. - Treat the middle chapters on thread-safe class design and concurrent collections as your day-to-day reference; return to them whenever you are about to add a lock. - Skim the performance and testing material on a first pass, then deep-read it once you have real profiling or flakiness problems to solve. - Keep a running list of the "rules" the book states (confinement, immutability, safe publication, interruption policy) and check your own code against them. - The book assumes fluency in core Java; if generics or the collections framework feel shaky, shore that up first so the concurrency discussion stays the focus. 【Coverage Limits】 The available excerpts consist only of the book's title, author, and a brief translator's note; they do not cover chapter contents, examples, or specific techniques, so this guide is synthesized from the book's well-known structure and themes rather than from detailed source text.