Optimizing Java (Benjamin J. Evans, James Gough etc.)（Z-Library）

【One-Line Pitch】 A practical, experiment-driven guide for intermediate-to-advanced Java developers who want to move beyond folklore and guesswork, learning how to measure, analyze, and tune JVM applications using quantitative methods and modern tools. 【Book Arc】 - **Opening (~0%–9%)**: Defines performance as an experimental science, introduces a taxonomy (throughput, latency, capacity, utilization, efficiency, scalability, degradation), and warns against outdated advice and "hero" performance culture. - **Early (~9%–25%)**: Covers measurement fundamentals—statistics, non-normal distributions, and the pitfalls of microbenchmarking—plus an introduction to JVM internals, including garbage collection basics (mark-sweep, HotSpot runtime, weak generational hypothesis). - **Middle (~25%–47%)**: Deep dive into advanced GC (CMS, G1, Shenandoah, C4, Balanced), GC logging/monitoring/tuning tools, and JIT compilation (tiered compilation, code cache, inlining, escape analysis, intrinsics). - **Late (~47%–60%)**: Focuses on Java language performance techniques—collections (ArrayList vs LinkedList, HashMap vs TreeMap), domain objects, finalization pitfalls, try-with-resources, and method handles—plus concurrency (JMM, locks, atomics, executors, fork/join, parallel streams). - **Ending (~60%–100%)**: Covers profiling tools (VisualVM, JFR, YourKit), allocation profiling, heap dump analysis, and high-performance logging/messaging (Agrona, SBE, Aeron), wrapping up with operational considerations. 【Key Takeaways】 - **Performance is an experimental science, not folklore** (Early): Define desired outcomes, measure, change, retest—this process builds quantitative objectives and avoids outdated advice that can harm modern JVMs. - **Java performance data is rarely normally distributed** (Early): Outliers matter (e.g., low-latency trading), so naive statistics like standard deviation mislead; sampling can miss critical events, and measurement itself adds overhead. - **Garbage collection tuning requires understanding collectors, not just flags** (Middle): From parallel collectors to G1 and Shenandoah, each has tradeoffs—knowing allocation, pause times, and GC roots is key to effective tuning. - **JIT compilation is where Java performance lives** (Middle): Inlining, escape analysis, loop unrolling, and intrinsics eliminate overhead; code that avoids small methods is now unfriendly to modern JITs. - **Collections and language techniques have real tradeoffs** (Late): ArrayList vs LinkedList, HashMap vs TreeMap—no universal winner; finalization is a pitfall, prefer try-with-resources and method handles. - **Concurrency is about choosing the right abstraction** (Late): From locks and atomics to executors and parallel streams, understanding the JMM and task abstraction prevents subtle bugs and improves scalability. - **Profiling is essential, but safepoint bias skews results** (Late): Tools like JFR and VisualVM help, but sampling can miss events; allocation profiling and heap dump analysis reveal hidden costs. - **High-performance messaging benefits from specialized libraries** (Ending): Agrona, SBE, and Aeron show how low-latency logging and messaging can be designed with minimal impact. 【Reading Tips】 - **Skim the foreword and preface** (~0%–9%): They set the philosophy—skip if you're already convinced, but the taxonomy chapter is worth a slow read. - **Deep-read the GC chapters** (~25%–47%): This is the heart of the book; focus on G1 and Shenandoah if you use modern JVMs, and skim legacy collectors (CMS, Serial) unless you maintain old systems. - **Treat the JIT chapters as reference material** (~47%–60%): Inlining and escape analysis are crucial, but don't memorize flags—understand the concepts and use JITWatch for practical insight. - **Use the collections and concurrency chapters as a checklist** (~60%–75%): These are practical, code-level techniques; skim for anti-patterns and apply selectively. - **The profiling and messaging chapters are for operational scenarios** (~75%–100%): If you're not doing low-latency work, skim Aeron/SBE; profiling tools are worth a deeper look for any production engineer. 【Coverage Limits】 This guide synthesizes the book's core themes—methodology, GC, JIT, language techniques, concurrency, profiling, and messaging—but does not cover specific code examples, detailed flag tables, or step-by-step tool walkthroughs, which require reading the full text.