Java Memory Management (Maaike van Putten Sean Kennedy) (z-library.sk, 1lib.sk, z-lib.sk)

【One-Line Pitch】 A practical, example-driven tour of how the JVM actually uses memory—stack, heap, and Metaspace—and how garbage collection and tuning keep Java applications fast. Best for Java developers, DevOps engineers, testers, and admins who want to move beyond "restart it and hope" toward diagnosing and preventing memory problems. 【Book Arc】 - **Opening (~0%–12%)**: Frames the problem—applications that slow down until restarted are usually suffering from poor memory management—and sets up the book's scope, audience, and required tooling (JDK 8+, an IDE, VisualVM). - **Early (~12%–34%)**: Builds fundamentals: how computer main memory differs from storage, what the JVM is and why bytecode enables "write once, run anywhere," then walks through the runtime data areas—stack, heap, Metaspace, constant pool, PC register, native method stack. - **Early–Middle (~34%–49%)**: Zooms into primitives versus objects, showing with visualizations how variables live on the stack and objects on the heap, and how Java's call-by-value treatment of references creates the "escaping references" security issue. - **Middle (~49%–61%)**: Explains heap generations and the minor garbage collection algorithm, then the full GC lifecycle—eligibility, marking, stop-the-world pauses, sweeping (normal, compacting, copying), and reference counting with islands of isolation. - **Late (~61%–71%)**: Surveys GC implementations (Serial, Parallel, CMS, G1, Z GC) and how to monitor them, then turns to the Metaspace: class loading, releasing memory, and what happens when it runs out or exceeds a JVM-set threshold. - **Ending (~71%–100%)**: Moves into practice—JVM memory tuning metrics and configuration, profiling to verify effects, and a chapter on spotting, solving, and avoiding memory leaks, including common mistakes that cause them. 【Key Takeaways】 - **Memory problems masquerade as performance problems** (Opening): the book opens by linking the familiar "restart to speed it up" symptom to memory filling up, which is the diagnostic thread running through every chapter. - **The JVM is a bytecode machine, not a Java machine** (Early): understanding that the JVM executes .class bytecode (also from Kotlin, Scala) explains why platform-specific JVMs deliver portability—and why memory behavior is a JVM concern, not a language one. - **Java memory is partitioned into distinct runtime areas** (Early): stack, heap, Metaspace, runtime constant pool, PC register, and native method stack each serve a role; knowing which holds what is the prerequisite for every later diagnosis. - **Stack versus heap placement determines lifetime and sharing** (Early–Middle): primitives and references live on the stack while objects live on the heap, and visualizing this during execution makes reference semantics concrete. - **References are passed by value, which can leak internals** (Middle): the "escaping references" issue shows how returning or storing a reference can expose mutable state—a security and correctness concern, not just a memory one. - **Garbage collection is expensive and worth minimizing** (Middle): eligibility, marking, stop-the-world pauses, and sweeping strategies (normal, compacting, copying) explain why GC tuning is a performance lever rather than an afterthought. - **GC implementations are a menu, not a default** (Late): Serial, Parallel, CMS, G1, and Z GC trade throughput, pause behavior, and complexity differently; monitoring tells you which trade-off you are actually getting. - **Leaks happen when unneeded objects stay reachable** (Ending): the book treats leaks as gradual slowdowns that eventually force restarts, and pairs detection techniques with the common coding mistakes that create them. 【Reading Tips】 - Deep-read the early chapters on stack/heap/Metaspace and the escaping-references discussion; these underpin everything later, and the visualizations are the book's strongest teaching device. - Skim the JVM background (bytecode, write-once-run-anywhere, the C malloc/free comparison) if you already know it—it is context, not the core. - Treat the GC implementations chapter as a reference to revisit when you actually choose or tune a collector; don't try to memorize all five at once. - Run the examples yourself with VisualVM open; the book assumes JDK 8+, an IDE, and VisualVM, and the tuning and leak chapters only land if you observe real metrics. - Read the memory-leak chapter with your own codebase in mind—its value is in recognizing your own patterns among the common mistakes. 【Coverage Limits】 The excerpts cover the front matter, table of contents, and early-to-mid chapters in detail, but the tuning, profiling, and memory-leak chapters are represented mainly by their descriptions rather than their content; specifics of those later chapters are not covered here.