Java Performance In-Depth Advice for Tuning and Programming Java 8, 11, and Beyond (Scott Oaks) (Z-Library)

【One-Line Pitch】 A practical, evidence-driven guide to making Java 8 and 11 applications faster by understanding what actually happens inside the JVM—written for developers and performance engineers who want to tune with data rather than folklore. 【Book Arc】 - **Opening (~0%–10%)**: Sets the philosophy—performance is mostly about writing better algorithms and less code, not hunting for a magic JVM flag; introduces the two knowledge domains (JVM behavior and Java platform behavior). - **Early (~10%–35%)**: Builds the measurement foundation: the four principles of performance testing, warm-up and JIT effects, choosing throughput vs. batch vs. response-time metrics, statistical rigor, and using JMH to avoid common benchmarking traps. - **Middle (~35%–55%)**: Equips you with a toolbox—OS-level analysis (e.g., iostat), JVM flag inspection via jinfo, and Java Flight Recorder/Mission Control for low-overhead profiling of GC, code, exceptions, and compilation. - **Late (~55%–85%)**: Moves into the JVM internals that dominate real performance: how the JIT compiles and optimizes bytecode, and how garbage collectors work and can be tuned to reduce pause and overhead. - **Ending (~85%–100%)**: Applies the knowledge to the Java platform itself—performance pitfalls in core APIs (collections, strings, logging) and in database-driven applications—closing the loop from measurement to code-level practice. 【Key Takeaways】 - **Write better algorithms first** (Opening): No JVM optimization can beat a fundamentally better data structure or algorithm; tuning flags cannot rescue poor design. - **Less code is faster code** (Opening): Fewer classes, objects, and executed instructions mean faster startup, less GC pressure, and better cache behavior—the "death by 1,000 cuts" of incremental bloat. - **Measure with the right metric** (Early): Throughput, elapsed/batch time, and response time are interrelated but serve different goals; picking the wrong one leads to optimizing the wrong thing. - **Warm-up is unavoidable in Java** (Early): JIT compilation, JPA caches, and OS file caching mean early measurements mislead; benchmark only after code reaches steady state. - **Use JMH and statistics, not ad-hoc loops** (Early): Proper warm-up iterations, forking, parameterization, and confidence intervals turn noisy guesses into defensible results. - **Don't tune flags blindly** (Middle): Hundreds of JVM flags exist, but most are for support engineers; change a flag only with a compelling, evidence-backed reason, and remember many are not dynamically manageable. - **JFR gives low-overhead visibility** (Middle): Java Flight Recorder exposes GC events, hot methods, exceptions, and compiler activity, making it a first stop for diagnosing production behavior. - **GC and JIT are the dominant JVM levers** (Late): Understanding tiered compilation and garbage collection behavior—and tuning or programming around them—delivers the largest JVM-side gains. 【Reading Tips】 - **Deep-read the testing chapters (Early)**: The four principles and JMH material are the foundation for every later claim; skimming here undermines the rest. - **Skim the tool catalog (Middle)**: Treat jinfo, iostat, and JFR sections as a reference to return to when diagnosing a specific problem, not as linear reading. - **Pair GC and JIT chapters with your own workload**: The concepts matter more than memorizing flags; test tuning ideas against a real application. - **Read the API and database chapters last, with your codebase in mind**: They are most useful as a checklist for auditing existing code rather than as abstract theory. 【Coverage Limits】 These excerpts emphasize the book's opening philosophy, performance-testing methodology, and tooling; the later JVM internals (GC, JIT) and Java API/database chapters are represented only by their stated scope, so this guide does not detail their specific techniques.