CPython’s garbage collector combines reference counting with a cyclic collector that uses generational strategies, fat pointers, and optimized object structures to efficiently identify and reclaim unreachable objects, handling cycles, weak references, and memory layout details while minimizing overhead.
In a reClojure 2022 keynote, Java’s creator James Gosling discussed how Java underpins AWS’s core services, the massive team optimizing its garbage collection, his love for functional programming, the challenges of turning research into practice, and his confidence in Oracle’s current stewardship of the language.
The article explains how the JVM executes Java bytecode, detailing bytecode structure, lambda compilation, JIT tiers and optimizations such as inlining and escape analysis, describes runtime memory areas and generational garbage collectors—including G1, ZGC, and Shenandoah—and offers key tuning flags for balancing throughput, latency, and heap size.
This article explains what constitutes garbage in the Java heap, compares reference‑counting and root‑reachability approaches, demonstrates a reference‑counting example, and reviews the main garbage‑collection algorithms and collectors (Serial, ParNew, Parallel Scavenge, Serial Old, Parallel Old, CMS, G1) used by modern JVMs.
This article introduces the four main JVM garbage collection algorithms—Mark‑Sweep, Copying, Mark‑Compact, and Generational collection—explaining their mechanisms, suitable scenarios, advantages, and drawbacks, and summarizing how they are applied to young and old generations in modern Java virtual machines.
This article analyzes a midnight HDFS DataNode failure caused by excessive GC and OOM due to Spark batch jobs, examines how an unexpected surge in block count overloaded default memory settings, and presents concrete remediation steps and optimization recommendations to stabilize the cluster.
This article provides a comprehensive overview of the Java Virtual Machine memory architecture, covering heap layout, object allocation, Metaspace, stack frames, native method stacks, program counters, direct memory, and code cache, complete with configuration tips and practical code examples.
This article explains how JVM memory management and various garbage collection algorithms affect Spark task performance, covering JVM fundamentals, GC concepts, common collectors, and practical tuning strategies to avoid full GC pauses and improve throughput.
Explore comprehensive JVM performance optimization, covering memory architecture, key tuning flags, garbage collector selection, common OOM scenarios, and essential monitoring tools such as jstack, jstat, JConsole, and VisualVM, with practical examples and code snippets to help you diagnose and resolve memory issues.
Oracle’s Enterprise Performance Pack, offered free to Java SE subscribers and OCI users, brings Java 17‑level memory management and performance enhancements—including modern garbage collection, compact strings, and improved observability—to legacy Java 8 applications, delivering up to 40% better memory and CPU efficiency under heavy loads.
This article details the investigation of a 2% timeout rate in a billion‑request‑per‑day ticket pricing service, identifies GC‑induced stop‑the‑world pauses as the main cause, and demonstrates how switching from ParNew+CMS to G1 and finally to ZGC dramatically reduces latency and timeout rates.
This article provides an in‑depth explanation of the JVM memory model, detailing heap, method area, stacks, direct memory, various garbage‑collection algorithms, collector types, and common JVM tuning parameters for performance optimization.
This article explains why non‑static inner classes in Java retain references to their outer class, causing memory leaks and eventual OutOfMemoryError, and demonstrates practical solutions such as avoiding references or converting the inner class to a static one, illustrated with code examples and debugging screenshots.
This article examines a puzzling 'prevent gc' comment in RocketMQ source, explains how inserting Thread.sleep(0) creates a JVM safepoint to avoid long GC pauses, explores counted vs uncounted loops, and demonstrates practical code modifications to improve performance.
This article explains how Apache BookKeeper's garbage collection works, detailing minor and major GC triggers, compression strategies, entry log size management, usage calculations, and provides a step‑by‑step code analysis of the GarbageCollectorThread implementation.
This article explains how Kubernetes' kubelet performs container and image garbage collection, details the configurable thresholds and limits, and presents step‑by‑step experiments that demonstrate the impact of different settings on image and container cleanup behavior.
Explore Java’s four reference types—strong, soft, weak, and phantom—understanding their behavior, garbage collection interactions, practical code examples, and best-use scenarios, while learning how to manage memory efficiently and avoid pitfalls such as improper finalize() overrides.
This article outlines the major new features of PHP 8 and PHP 7, explains why PHP 7 outperforms PHP 5, describes the execution flow, web‑request lifecycle, underlying architecture, data structures, garbage‑collection mechanism, and the PHP‑FPM master‑worker model with optimization tips.
This article explains how the V8 JavaScript engine manages memory through stack and heap allocation, describes its generational garbage‑collection architecture—including New Space, Old Space, and various GC algorithms—and offers practical optimization techniques to reduce pause times and improve performance.
This article explains the JVM memory layout, covering the heap (including Xms/Xmx tuning, Young/Old generations, and garbage collection), Metaspace versus PermGen, the thread‑private JVM stack and native method stack, and the program counter register, with practical code examples.
This article explains the JVM memory layout, covering the heap (young and old generations), Metaspace, virtual machine stacks, native method stacks, and the program‑counter register, while describing their roles, configuration parameters and how they interact during garbage collection and method execution.
This article demystifies the JVM’s runtime data areas and illustrates, with a simple Java example and animation, how a program’s bytecode is executed—from the program counter and stack frames to heap allocation and garbage collection—providing a clear, step‑by‑step view of Java execution.
Since JDK 8, HotSpot’s garbage collectors have undergone extensive refinements—introducing G1 as default, adding ZGC and Shenandoah, and optimizing Parallel GC—resulting in notable gains in throughput, reduced pause latency, and lower auxiliary memory usage, as demonstrated by SPECjbb2015 benchmarks across JDK 8 to JDK 18.
Based on Google’s TCMalloc, Go’s automatic memory system organizes memory into pages and spans, uses per‑processor mcache and shared mcentral for size‑class allocation, and employs a concurrent tri‑color mark‑sweep garbage collector triggered by heap usage or large allocations, illustrating the full allocation‑to‑reclamation pipeline.
This article explains how the Java Virtual Machine achieves write‑once‑run‑anywhere by abstracting platform differences, then details the JVM’s internal components—including the class‑loader subsystem, runtime data areas such as heap, stack, method area, and program counter—followed by code examples and analysis of object layout, pointer compression, and memory allocation strategies.
This article explains ZGC’s evolution from an experimental feature in JDK 11 to a production‑ready collector in JDK 15, detailing its sub‑10 ms pause guarantee, memory‑mapping architecture, colored pointers, region layout, read barriers, and the multi‑phase concurrent collection process that together deliver low‑latency, high‑throughput garbage collection for Java applications.
This article explains the JVM memory architecture, covering the heap (young and old generations, Eden and Survivor spaces), Metaspace, virtual machine stacks, native method stacks, and the program counter register, while also illustrating key JVM parameters and bytecode execution with examples.
This article provides a comprehensive overview of JVM memory layout, explains major garbage‑collection algorithms and collectors, details how different memory regions cooperate, and offers practical tuning steps and tool usage for diagnosing GC issues in Java applications.
This article explains Java constructors, the importance of providing a no‑arg constructor, method overloading rules and type promotion, the use of the this and static keywords, memory cleanup strategies, garbage‑collector algorithms, JIT compilation, member initialization order, and enum usage with clear code examples.
hyengine is a lightweight, high‑performance mobile execution engine that unifies WebAssembly, JavaScript, Python and Lua via a compiler and VM, offering JIT compilation, register allocation, inline‑cache optimizations, a custom allocator (hymalloc) and a concurrent three‑color garbage collector (hygc), achieving substantial speed‑ups on macOS and Android.
The 2022 Java ecosystem report reveals Java 11 surpassing Java 8 as the dominant runtime, highlights the modest adoption of non‑LTS releases like Java 14, shows Oracle’s market share shrinking while Amazon rises, and examines how container‑based deployments affect CPU, memory, and garbage‑collector choices.
ZGC (Z Garbage Collector) is a scalable, low‑latency collector introduced in JDK 11, featuring sub‑millisecond pause times, region‑based memory layout, colored pointers, NUMA awareness, and concurrent phases, with detailed explanations of its architecture, parameters, triggers, and log analysis.
ZGC, introduced in JDK 11 and stabilized in JDK 15, is a low‑latency, region‑based, concurrent garbage collector that aims for sub‑millisecond pause times regardless of heap size, leveraging colored pointers, NUMA awareness, multi‑mapping, and read barriers to achieve efficient memory reclamation.
This article explains JavaScript's memory lifecycle, defines memory leaks, enumerates typical leak patterns such as accidental globals, timers, closures and DOM references, and describes the underlying garbage‑collection strategies (mark‑and‑sweep and reference counting) together with practical mitigation techniques.
This article demystifies JavaScript closures, explains how V8 builds scope chains and closure objects during compilation, and demonstrates why closures can cause memory leaks by retaining references, illustrated with multiple runnable code examples and practical debugging tips.
This article introduces hyengine, a lightweight, high‑performance engine designed to run multiple scripting languages such as JavaScript, WebAssembly, and Python on mobile devices, detailing its architecture, JIT compilation, optimizer passes, memory allocator, garbage collector, and performance benchmarks compared to LLVM and other runtimes.
This article explains the complete lifecycle of Java object creation, covering the JVM's handling of the new bytecode, class loading, memory allocation strategies such as pointer bumping and free lists, object header structure, layout, and tools for inspecting object memory.
This article explains the inner workings of Java's CMS and G1 garbage collectors, detailing their four-phase processes, the need for stop‑the‑world pauses, strategies like incremental update and SATB to handle missed marks, and compares their advantages, drawbacks, and suitable replacement scenarios.
Explore the structure of Java's memory regions—including the program counter, stacks, heap, and method area—along with allocation algorithms, object layout, garbage collection roots, and common pitfalls such as memory leaks and StackOverflowError, providing a comprehensive guide for JVM developers.
This article explains Java garbage collection fundamentals, covering why GC is needed, how it works, reference types, major collection algorithms, generational strategies, specific collectors like CMS and G1, and practical tuning and allocation rules for JVM memory management.
This article explains the JEP 423 proposal to fix regions in the G1 garbage collector, allowing Java threads to avoid pauses during JNI critical sections and reducing GC latency, while discussing implementation details, potential heap exhaustion risks, and upcoming JDK release timelines.
This newsletter curates a collection of technical articles covering WebAssembly's future, Deno's 2021 progress, JavaScript garbage collection fundamentals, front‑end debugging best practices, modern CSS color systems, FormData usage, and advanced JavaScript features like iterators and generators.
The article explains how JavaScript engines store variables in stack and heap memory, clarifies why const primitives are immutable while object properties can change, shows that new objects reside in heap, and discusses allocation efficiency and garbage‑collection behavior of both memory regions.
The article thoroughly explains Android ART’s Concurrent Copying (CC) garbage collector—its terminology, correctness and progress requirements, engineering challenges, classic and Android‑specific algorithms, region‑based design with bump‑pointer allocation, performance benefits such as 32% lower heap usage and sub‑millisecond pauses, and its trade‑offs including doubled reserved heap space and migration overhead.
This article explains the theory behind JVM garbage collection algorithms, details various collectors such as Serial, Parallel, CMS, and G1, compares their strengths and weaknesses, and explores advanced concepts like three‑color marking, write barriers, SATB, and memory management parameters.
This article provides a comprehensive overview of the Java Virtual Machine, covering its core responsibilities, runtime memory layout, class‑loading process, object allocation and layout, garbage‑collection theories and algorithms, common collectors, useful JVM tools, and tuning parameters.
This article explains the JVM runtime memory areas, the fundamentals of garbage collection, generational heap organization, and the characteristics of major GC collectors, providing practical insights and optimization tips for Java developers seeking to understand and improve JVM performance.
This article explains Python's automatic garbage collection, covering reference counting, the mark-and-sweep algorithm, generational collection, default thresholds, and when to disable or adjust the collector for performance‑critical code.
The article details three Xianyu backend incidents where Full GC pauses caused latency spikes or outages, analyzes root causes ranging from survivor space shortage and mis‑tuned CMS to oversized async Log4j events and massive string‑concatenation logs, and presents remediation steps such as switching to G1GC, adjusting Log4j settings, and using parameterized logging to eliminate the pauses.
Over a month we reduced Full GC occurrences from around 40 times per day to roughly one every ten days by systematically adjusting JVM parameters, addressing memory leaks, and fine‑tuning metaspace and young generation settings, ultimately achieving lower GC pause times and higher server throughput.
This article explains how Go's garbage collection has progressed from the simple stop‑the‑world mark‑and‑sweep algorithm in Go 1.3, through the tri‑color concurrent marking with insert and delete write barriers in Go 1.5, to the hybrid write‑barrier approach introduced in Go 1.8 that dramatically reduces pause times while preserving memory safety.
This comprehensive guide explains the JVM memory model, details each memory region, compares major garbage‑collection algorithms, and lists essential JVM tuning parameters for optimal Java performance.
This article explains how Vue 3 uses a WeakMap as a cache to avoid duplicate proxies, why WeakMap is preferred over Map for memory‑safe reactive objects, and explores WeakMap fundamentals, its methods, garbage‑collection strategies, and practical applications such as DOM storage and private class fields.
This comprehensive guide explores the inner workings of the Java Virtual Machine, covering memory regions, garbage‑collection algorithms, class‑file structure, bytecode instructions, class loading mechanisms, and method dispatch strategies, providing clear explanations and code examples for developers seeking a deeper understanding of JVM fundamentals.
This article explains how Python’s automatic garbage collection works, covering reference counting, the problems of cyclic references, the mark‑and‑sweep algorithm, generational collection, default thresholds, and when and how to manually control the collector with code examples.
This article explains how the V8 JavaScript engine allocates memory, why garbage collection is necessary, describes the memory layout of new and old generations, reviews common GC algorithms such as reference counting, mark‑sweep, mark‑compact and incremental marking, and offers practical tips for writing high‑performance JavaScript code.
This article provides an in‑depth overview of the JVM runtime data structures, memory regions, garbage‑collection algorithms, GC roots, reference types, stop‑the‑world pauses, OopMap, safe points, stack‑overflow handling, class‑loading mechanisms, the parent‑delegation model, object stack allocation, and object layout, offering practical insights for Java developers preparing for interviews.
This article explains the difference between memory leaks and overflow, whether young GC triggers stop‑the‑world pauses, distinguishes major GC from full GC, and describes Java's direct memory usage, providing clear insights into Java memory management and performance considerations.
This article provides an in-depth exploration of Java's JVM memory architecture, garbage collection algorithms, class file structure, class loading process, bytecode execution, and method dispatch mechanisms, offering practical code examples and visual diagrams to help developers understand and optimize JVM performance.
This comprehensive guide explains the JVM memory layout, class‑loading and object‑creation process, the parent‑delegation model, various garbage‑collection algorithms and collectors, GC roots, triggers for YGC and Full GC, and practical tuning parameters to improve Java application performance.
This article provides a comprehensive, interview‑focused guide to the Java Virtual Machine, covering memory regions, garbage‑collection algorithms, reference types, GC roots, STW pauses, OopMap, safe points, stack overflow, class loading, the parent‑delegation model, stack allocation, and object layout, all with clear explanations and diagrams.
By replacing the default Parallel GC with a ParNew‑CMS collector, enlarging the Young generation, fixing Metaspace settings, and tuning CMS occupancy thresholds, the video service cut Young and Full GC pauses dramatically, lowered Full GC count by over 80%, and achieved more than 30% P99 latency reduction, with some APIs improving up to 80%.
This article introduces the fundamentals of Android Runtime (ART) garbage collection, covering its historical background, key milestones, core features such as RegionTLAB, read barriers, pause behavior, generational support, target heap size calculations, multiplier impact, GC trigger thresholds, Systrace analysis, and parameter tuning strategies.
This article explains how the JVM determines object liveness, describes reference counting and reachability analysis, lists GC Roots, and provides clear visual and code examples of the main garbage‑collection algorithms—mark‑sweep, copy, mark‑compact, and generational collection—highlighting their advantages, drawbacks, and typical use cases.
This article explains the three‑color marking algorithm used by Java’s CMS and G1 garbage collectors, detailing the color semantics, algorithmic steps, common pitfalls such as floating garbage and miss‑marking, and the specific solutions each collector employs to minimize stop‑the‑world pauses and improve memory reclamation efficiency.
This article provides a comprehensive overview of the Java Virtual Machine, explaining its main purpose, memory regions, class‑loading mechanism, object creation process, memory allocation strategies, object layout, reference handling, garbage‑collection theories, algorithms, and common JVM tuning commands.
This article explains the architecture of the OpenJDK HotSpot JVM, covering bytecode execution, JIT compilation, garbage collection, ergonomic defaults, configuration options, their lifecycle, and practical tuning advice to help developers optimize Java applications for various environments.
This article analyzes the main factors that contribute to Young Generation GC (YGC) latency in the JVM, covering safe‑point pauses, live object scanning and marking, object copying, GC log overhead, and OS activity, and offers practical tips for diagnosing and reducing pause times.
The article explains Android R’s ART runtime garbage‑collection configuration and heap layout—including RegionSpace, ImageSpace, ZygoteSpace, non‑moving and LargeObject spaces—details concurrent, native, transition and blocking GC types, illustrates real‑world performance issues, and offers optimization strategies for developers.
The article reviews benchmark results showing Java 17’s speed gains over earlier releases, outlines upcoming Java 18 features such as the third‑incubated Vector API, preview record and array patterns, UTF‑8 default charset, and JavaDoc snippet support, and points to further reading.
This article explains how Java objects are laid out in memory, compares the heap locations of fields and local variables, analyzes the byte size of a plain new Object() with and without compressed oops, demonstrates measurement using JOL, and reviews related heap regions and garbage‑collection concepts.
The article explains Java 17’s release as the first LTS since Java 11, details Oracle’s new free JDK license, and presents a thorough OptaPlanner benchmark that compares JDK 11, 16, and 17 using G1GC and ParallelGC, revealing performance gains and guiding upgrade decisions.
This article reviews the most important JDK 17 updates to HotSpot’s G1 and Parallel garbage collectors, covering new large‑page support, dynamic reference processing, preventive collection, memory‑saving tweaks, and upcoming JDK 18 enhancements that impact performance and pause times.
This article explains Java 17’s new long‑term‑support release, Oracle’s free JDK licensing, and presents OptaPlanner benchmark results comparing JDK 11, 16 and 17 with G1GC and ParallelGC, highlighting performance gains and migration considerations for developers in production.
This article compiles a series of JVM interview questions covering heap partitioning, garbage‑collection algorithms, collector types, memory coordination, tuning strategies, and practical tooling such as jstat, jmap, and MAT, providing detailed explanations and command‑line examples for each topic.
This article explains how Shenandoah OpenJDK's new concurrent thread‑stack processing, introduced in JDK 17, dramatically reduces garbage‑collection pause times to sub‑millisecond levels by using stack watermarks, and provides practical configuration guidance and benchmark results.
This article provides a comprehensive JavaScript guide covering primitive and reference types, Symbol and BigInt nuances, type‑checking operators, stack vs heap memory, deep and shallow copying techniques, and practical garbage‑collection strategies to help developers ace interview questions.
This article explains how frequent use of Node.js's vm module can cause out‑of‑memory crashes in V8 due to an uncollected compilation cache, the role of the --always‑promote‑young‑mc flag, and practical work‑arounds for Node.js 12, 14 and 16.
This article provides a comprehensive overview of the Java Virtual Machine memory layout, explaining each region such as the heap, metaspace, stack, program counter, direct memory and code cache, along with allocation strategies, tuning parameters, and practical OOM demonstrations.
The article details a full‑link tracing system for Node.js that leverages experimental async_hooks to monitor asynchronous resource lifecycles, builds an invoke‑tree to map parent‑child relationships, implements garbage collection, and provides a ZoneContext API for propagating custom tracing data across async call chains.
This article introduces the most frequently used JVM startup parameters, explains their effects on garbage collection, heap configuration, class loading monitoring, and out‑of‑memory handling, and provides example outputs to help developers tune Java applications for large‑scale projects.
This article explains the Java heap structure, generational layouts in JDK 1.7 and 1.8, the G1 collector's region-based approach, and detailed object allocation rules including Eden placement, large object handling, promotion thresholds, and space allocation guarantees.
The article compares Java’s mature, generational garbage collector—using mark‑copy for young objects, mark‑sweep/compact for old, with sophisticated write barriers and fragmentation handling—to Go’s non‑generational, concurrent tri‑color mark‑sweep collector that relies on a span‑based memory pool, TCMalloc optimizations, and simpler root selection.
The article shares the author’s experience reading the third edition of "Understanding the JVM," focusing on JVM memory management, garbage‑collection algorithms, tuning strategies, and practical tools, while providing concise summaries of each book section and actionable advice for Java performance optimization.
The article details Go’s runtime memory architecture—including pages, spans, mcache, and size classes—and explains its non‑generational concurrent tri‑color mark‑and‑sweep garbage collector, the required write‑barrier techniques, and the collector’s evolution, phases, trigger mechanisms, and practical code examples across Go 1.0‑1.16.
The article explains Java’s automatic memory management, detailing JVM memory regions, object liveness via reachability analysis, allocation strategies, and the main garbage‑collection algorithms—Mark‑Sweep, Mark‑Copy, Mark‑Compact—and compares HotSpot collectors such as Serial, Parallel, CMS and G1, guiding developers to choose the best fit for their workloads.
This article explains what memory leaks are in Java, compares them with C++ leaks, describes the garbage collection mechanism, lists common leak sources such as static collections, listeners, and singletons, and provides practical guidelines and tools to detect and prevent them.
The article provides a comprehensive overview of Java garbage‑collection algorithms, JVM memory regions, object reachability analysis, the semantics of volatile, synchronized and ReentrantLock, thread‑pool creation and operation, deadlock examples, distributed‑lock strategies, and related tooling such as JUC utilities and Git conflict handling.
Over a month of systematic JVM tuning reduced Full GC from 40 times per day to once every ten days and halved Young GC duration by adjusting heap sizes, survivor ratios, and metaspace settings while investigating and fixing a memory leak caused by an anonymous inner class listener.
This article demonstrates how to trigger and interpret JVM garbage‑collection logs by creating a small Java program, configuring heap parameters, and dissecting both young and full GC log entries to reveal causes, memory changes, and performance implications.
This article explains the G1 garbage collector’s architecture, region types, pause‑time prediction model, memory allocation parameters, collection phases, and tuning considerations, providing code examples and practical insights to improve performance for Java developers.
This article details 58.com’s big‑data team’s migration of HBase clusters from CMS/G1 to the low‑latency Z Garbage Collector, explains ZGC’s design and key techniques, presents performance test results versus CMS, discusses tuning parameters, and shares practical lessons from production deployment.
Over a month, we reduced Full GC occurrences on a 2‑core, 4 GB JVM cluster from roughly 40 times per day to once every ten days, while halving Young GC duration, by adjusting heap parameters, fixing memory leaks, and tuning metaspace, ultimately improving server throughput and stability.
Tencent's Kona JDK 11 introduces a production‑ready ZGC implementation that reduces Java garbage‑collection stop‑the‑world pauses to under 10 ms, enabling ultra‑low‑latency online services across massive heaps while maintaining acceptable throughput, and the article details its design, tuning, and real‑world deployments.
This article explains the JVM heap memory area, its default and configurable sizes, the generational layout (Eden, Survivor, Old), how objects are allocated and promoted, and the various garbage‑collection mechanisms and JVM parameters that affect performance and memory usage.
This article explains how Java determines which objects are eligible for garbage collection using reference counting and reachability analysis, describes the main garbage‑collection algorithms such as mark‑sweep, mark‑compact, and mark‑copy, and outlines the generational GC process including MinorGC and survivor spaces.
This article provides an overview of the most common Java JVM garbage collectors—including Serial, ParNew, Parallel, Serial Old, CMS, Parallel Old, and G1—detailing their characteristics, advantages, disadvantages, typical usage scenarios, and JVM tuning parameters for optimal performance.
Over a month of JVM tuning, the author reduced Full GC from more than 40 times per day to once every ten days and halved Young GC duration by adjusting heap sizes, fixing memory leaks, and tuning metaspace, ultimately improving server throughput and stability.
This article explains how ThreadLocal works in Java, demonstrates how improper use can cause Out‑Of‑Memory errors, analyzes the underlying cause in ThreadLocalMap, and provides a simple fix by invoking remove() after use to avoid memory leaks.
This guide compiles all JVM garbage‑collection parameters—standard, non‑standard, and experimental—explaining their meanings and how to configure them to minimize pause times, improve performance, and tailor GC behavior for different application types and hardware environments.
