Java高并发编程详解：深入理解并发核心库（Java高并发编程详解：多线程与架构设计姊妹篇） (Java核心技术系列) (汪文君)（Z-Library）

【One-Line Pitch】 A hands-on guide to Java's concurrency core libraries that moves from benchmarking methodology to atomic types, synchronizers, locks, and rate limiting, written for developers who already know basic multithreading and want production-grade fluency with the JUC toolkit. 【Book Arc】 - **Opening (~0%–10%)**: Establishes measurement discipline first — JMH benchmark modes, warmup/measurement iterations, forking, state scopes, and setup/teardown — so later performance claims about locks and containers have a credible basis. - **Early (~10%–30%)**: Covers atomicity and the atomic type family: why volatile alone cannot guarantee atomicity, CAS internals down to Unsafe and HotSpot C++ code, and field updaters that atomically modify plain object attributes. - **Early–Middle (~30%–45%)**: Works through synchronizers and explicit locks — CyclicBarrier reset semantics, Semaphore-based try-lock, Exchanger, Phaser arrival/advance methods, and ReentrantLock pitfalls such as unreleased locks and cross-lock deadlock. - **Middle (~45%–55%)**: Benchmarks lock strategies head-to-head, showing read-write locks can underperform under read-only load, and introduces Condition's await/signal family plus Guava's Monitor and RateLimiter for leaky-bucket throttling. - **Late (beyond ~55%)**: Excerpts indicate a shift toward concurrent containers and data-structure internals (e.g., a comparator-driven priority list), but the sampled material does not cover the ExecutorService, Stream, or Metrics chapters named in the preface. 【Key Takeaways】 - **Benchmark before you believe** (Opening): JMH's modes, warmup, forking, and state scoping exist because naive timing lies; the book treats this as prerequisite knowledge for every later performance comparison. - **Volatile gives visibility and ordering, not atomicity** (Early): Compound operations like x++ decompose into read-modify-write steps, and even 64-bit writes can split into two 32-bit operations — the conceptual bridge into atomic types. - **CAS is the engine under the atomic classes** (Early): compareAndSet traces through Unsafe into HotSpot's C++ compare-exchange, explaining both the power and the platform-level cost of lock-free updates. - **Field updaters retrofit atomicity onto existing classes** (Early): AtomicIntegerFieldUpdater and its siblings let you atomically update volatile fields without changing the field's declared type — useful for memory-sensitive designs. - **Synchronizers solve coordination, not just mutual exclusion** (Early–Middle): CyclicBarrier, Semaphore, Exchanger, and Phaser each target a distinct rendezvous pattern; misuse, such as releasing a permit you never acquired in a finally block, silently corrupts the permit count. - **Lock discipline prevents the worst failures** (Middle): A lock never released leaves AQS's owner reference pointing at a dead thread, and cross-acquiring two locks invites deadlock — the book demonstrates both with diagnostic tooling. - **Read-write locks are not automatically faster** (Middle): Benchmarks show read locks losing to plain locks under read-only contention, motivating StampedLock's introduction in JDK 1.8. - **Rate limiting is a first-class concurrency concern** (Middle): The leaky-bucket model and Guava's RateLimiter show how to cap dispatch rate, with the rate ideally made configurable. 【Reading Tips】 - Deep-read the JMH chapter even if benchmarking feels tangential — the book explicitly assumes it before the lock-comparison chapters, and the numbers there are only meaningful if you understand the methodology. - Skim the Unsafe/HotSpot C++ walkthroughs on a first pass; return to them when you need to reason about CAS failure or memory barriers. - Treat the synchronizer chapter as a decision guide: for each tool, note the specific coordination problem it solves and the misuse pattern the author warns about. - Run the examples rather than reading them — several pitfalls (permit leakage, deadlock, unreleased locks) only land when you observe the failure and inspect the process with JVM tools. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering roughly the first half of the book; the ExecutorService, Java 8 Stream, and Metrics chapters mentioned in the preface are not represented in the sampled material, so their treatment is not assessed here.