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

【One-Line Pitch】 A deep-dive reference for Java developers who want to master the concurrency core library (java.util.concurrent) and measure performance scientifically with JMH, covering everything from atomic types and locks to parallel streams and metrics. 【Book Arc】 - **Opening (~0%–13%)**: Introduces the book’s scope and structure, positioning it as the sequel to the author’s first concurrency book. It outlines four parts: JMH benchmarking, the concurrency package (Chapters 2–5), Java 8 Streams, and the Metrics library, setting expectations for a systematic, practice-oriented reference. - **Early (~13%–29%)**: Dives into JMH (Java Microbenchmark Harness), starting with why naive benchmarking (e.g., using Stopwatch) is flawed due to JVM optimizations and unfair test environments. It then walks through a first JMH example, showing how annotations like @Benchmark, @State, and OptionsBuilder produce rigorous, statistically meaningful results. - **Early (~29%–42%)**: Explains JMH’s core usage patterns in detail: the necessity of @Benchmark, the roles of Warmup and Measurement (with global vs. method-level configuration), and the four BenchmarkModes—AverageTime, Throughput, SampleTime, and SingleShotTime—each suited to different performance questions, from average latency to cold-start behavior. - **Middle (~42%–48%)**: Covers advanced JMH features, including multi-mode benchmarking (e.g., combining AverageTime and Throughput) and the three State scopes (Thread, Benchmark, and Group). The key insight is that Scope.Thread creates a new instance per thread, while Scope.Benchmark shares one instance across threads, which is critical for testing shared-data performance. - **Late (not covered in excerpts)**: The book continues with detailed chapters on atomic types (e.g., AtomicInteger, AtomicReference, sun.misc.Unsafe), concurrency tools (CountDownLatch, CyclicBarrier, Semaphore, Phaser, locks, Condition, StampedLock, Guava’s Monitor and RateLimiter), concurrent containers (BlockingQueue, ConcurrentHashMap, CopyOnWrite), ExecutorService and Future families, plus Java 8 parallel Streams and Metrics. These sections are referenced in the table of contents but not detailed in the provided excerpts. 【Key Takeaways】 - **JMH is essential for credible performance testing** (Early): Naive timing with Stopwatch is unreliable because JVM optimizations (e.g., JIT, loop unrolling) and unfair execution environments skew results. JMH provides warmup, measurement iterations, and forked JVMs to produce statistically sound benchmarks, making it a must-have tool for any serious Java developer. - **Warmup and Measurement are the backbone of JMH** (Early): Warmup iterations let the JVM reach a steady state (after class loading and JIT compilation) before real data is collected. Measurement iterations are the only ones counted in results; you can configure these globally via Options or per-method via annotations, with method-level settings overriding class-level ones. - **Choose the right BenchmarkMode for your question** (Middle): AverageTime measures latency per operation, Throughput measures operations per unit time, SampleTime provides a histogram and percentiles (useful for detecting outliers), and SingleShotTime is for cold-start tests. Using Mode.All runs all modes at once for a comprehensive view. - **State scopes control test realism** (Middle): Scope.Thread creates a new instance per thread (ideal for isolated tests), while Scope.Benchmark shares one instance across threads (essential for testing concurrent access to shared data). Misusing these scopes can invalidate your benchmark results. - **The concurrency package is a toolbox for specific problems** (Late, from TOC): The book systematically covers atomic types (for lock-free updates), tools like CountDownLatch and Semaphore (for coordination and limiting), and concurrent containers (for thread-safe data structures). Each is presented with use cases and performance comparisons, making it a practical reference rather than just theory. - **Beyond the core library, the book adds modern Java features** (Late, from TOC): It includes Java 8 parallel Streams (with a focus on customizing parallel streams) and the Metrics library (used by Kafka, Spark, and Spring Cloud), showing how to measure and monitor performance in production-grade systems. 【Reading Tips】 - **Skim the JMH chapter first, then use it as a reference**: Chapter 1 is foundational because later chapters use JMH for performance comparisons. Read the basics (annotations, modes, State) carefully, but skim the Profiler section (StackProfiler, GcProfiler) until you need it for specific debugging. - **Deep-read Chapter 2 (Atomic Types) and Chapter 3 (Tools)**: These are the core of the book. Focus on the "inner workings" sections (e.g., how AtomicInteger uses CAS) and the comparisons (e.g., ReentrantLock vs. synchronized) to build a mental model of when to use what. - **Treat Chapter 4 (Containers) as a decision guide**: Instead of memorizing every class, learn the trade-offs: BlockingQueue variants for producer-consumer, ConcurrentHashMap for maps, and CopyOnWrite for read-heavy scenarios. The lock-free data structure section is advanced—skim it unless you need custom implementations. - **Use Chapter 5 (ExecutorService) for real-world patterns**: Pay attention to Future’s limitations and how CompletableFuture and CompletionService solve them. This is where the book shifts from theory to practical async programming, so read the examples carefully. - **Skip or skim the Streams and Metrics chapters if you’re short on time**: These are valuable but somewhat separate from the concurrency core. If you already use parallel streams or Metrics, skim for the custom parallel stream details; otherwise, treat them as bonus material. 【Coverage Limits】 This guide is based on excerpts covering the book’s front matter, table of contents, and the first half of Chapter 1 (JMH). Detailed content on atomic types, concurrency tools, containers, ExecutorService, Streams, and Metrics is referenced but not covered in the provided material.