Tagged articles
Generational GC
24 articles · Page 1 of 1
JDK 25 introduces the generational Shenandoah garbage collector as a production‑ready feature, offering lower pause times, higher throughput, and better memory efficiency compared to G1 and ZGC, while remaining optional via the -XX:ShenandoahGCMode=generational flag and preserving compatibility with existing scripts.
Generational GCJDK 25Java
0 likes · 8 min read

The article examines JDK 21's Generational ZGC, explaining its weak generational hypothesis, heap partitioning, performance gains such as a 10% throughput increase and reduced pause times, mitigation of allocation stalls, migration steps, and diagnostic tools for developers.
Generational GCJDK 21Java
0 likes · 6 min read

JVM’s generational garbage collection divides the heap into young and old generations, using two Survivor spaces to incrementally age objects, apply a copying algorithm, reduce fragmentation, improve memory utilization, and accelerate short‑lived object reclamation, ultimately enhancing overall GC performance.
Generational GCJVMSurvivor Space
0 likes · 4 min read

This article provides a comprehensive overview of garbage collection techniques, covering reference counting, reachability analysis, generational management, copy, mark‑sweep, and mark‑compact algorithms, and explains the JVM's serial, parallel, CMS, and G1 collectors along with their operational characteristics and trade‑offs.
Copy AlgorithmG1Generational GC
0 likes · 9 min read

The article surveys seven common garbage‑collection algorithms—Mark‑Sweep, Reference Counting, Copying, Mark‑Compact, Conservative, Generational, and Incremental/Tri‑color—explaining their principles, strengths, weaknesses, evaluation criteria such as throughput and pause time, and practical optimizations, emphasizing that the best choice depends on specific application needs.
GC algorithmsGenerational GCMark‑Sweep
0 likes · 42 min read

This article provides a comprehensive overview of the Java Virtual Machine's runtime memory areas, object layout, garbage collection roots, marking algorithms, generational hypotheses, remembered sets, and the main GC algorithms such as Mark‑Sweep, Mark‑Copy, and Mark‑Compact, explaining their principles and trade‑offs.
Generational GCJVMRuntime
0 likes · 16 min read

This article explains the concept of automatic garbage collection in Java, detailing the mark‑sweep‑compact process, the need for generational collection, and how objects move through Eden, Survivor, and Old generations, while also noting promotional links for further resources.
Generational GCJVMJava
0 likes · 8 min read

Java 21, slated for release on September 19, 2023 as the next LTS version after Java 17, will drop the experimental Generational Shenandoah garbage‑collector feature during its Ramp‑down phase due to insufficient readiness, with the change slated for removal by the June 14 review deadline.
Generational GCJDK21Java
0 likes · 4 min read

This article explains the JVM's runtime memory structure—including the method area, heap, stacks, and program counter—details object memory layout, garbage collection roots, marking algorithms, generational models, and various GC algorithms such as mark‑sweep, mark‑copy, and mark‑compact, providing a comprehensive overview.
GC algorithmsGenerational GCJVM
0 likes · 16 min read


21CTOFeb 1, 2023 · Fundamentals
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.
Generational GCPythonReference Counting
0 likes · 21 min read

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.
CopyingGenerational GCJVM
0 likes · 7 min read

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.
Generational GCMark-and-SweepPython
0 likes · 7 min read

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.
Generational GCMark‑SweepReference Counting
0 likes · 7 min read

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.
Generational GCJavaMark‑Sweep
0 likes · 7 min read

This article explains Python's memory management, covering reference counting, its limitations with cyclic references, and how the interpreter supplements it with mark‑sweep and generational garbage‑collection algorithms, complete with code examples and detailed diagrams of the underlying mechanisms.
Generational GCMark‑SweepPython
0 likes · 47 min read

This article explains Python's memory management, covering object references, identity via id(), reference counting, caching of small objects, the use of the is operator, handling of reference cycles with objgraph, manual reference deletion, and the generational garbage collection mechanism including thresholds and cycle detection.
Generational GCPythonReference Counting
0 likes · 12 min read

This article explains Python's garbage collection mechanism, covering object management, reference counting, cyclic reference handling, the mark‑and‑sweep algorithm, and generational collection thresholds, with illustrative code examples and detailed explanations of each step.
Generational GCReference Countinggarbage collection
0 likes · 9 min read

Python abstracts memory management through reference counting, handles cyclic references with a generational garbage collector, and employs the weak generational hypothesis to efficiently reclaim objects, as illustrated by code examples demonstrating object creation, deletion, and the behavior of different GC generations.
Generational GCReference Countinggarbage collection
0 likes · 8 min read

This article explains the JVM memory model, how the JVM decides whether an object is alive using reference counting and reachability analysis, and describes the main garbage‑collection algorithms—including mark‑sweep, mark‑compact, copying, and generational collection—along with their advantages and drawbacks.
Generational GCJVMReachability Analysis
0 likes · 8 min read

This article explains how Java's automatic garbage collection works, covering the mark‑sweep‑compact phases, the need for generational collection, the structure of the JVM heap (young, old, and permanent generations), and the detailed object promotion process illustrated with diagrams.
Generational GCJVMJava
0 likes · 7 min read

This article explains Java garbage collection in depth, covering its definition, historical origins, reference‑counting and reachability algorithms, GC roots, memory regions such as Eden, Survivor and Old, and the main collection strategies like Mark‑Sweep, Copying, Mark‑Compact and Generational collection.
Generational GCJVMJava
0 likes · 15 min read

Java's garbage collection mechanism, introduced to simplify memory management, employs various algorithms such as reference counting, tracing (mark‑and‑sweep), compacting, copying, and generational collection, each with distinct advantages, drawbacks, and implementation details, while also addressing common memory‑leak pitfalls.
AlgorithmsGenerational GCgarbage collection
0 likes · 10 min read


21CTOSep 1, 2017 · Fundamentals
This article critically examines Go’s advertised sub‑10 ms garbage‑collection pauses, compares its concurrent mark‑sweep collector with Java’s GC algorithms, and explores the fundamental trade‑offs of throughput, pause time, memory overhead, and scalability that shape modern garbage‑collector design.
Generational GCGoJava
0 likes · 18 min read

This article explains the rationale behind generational garbage collection in the JVM, describes the Young, Old, and Permanent generations, details Scavenge and Full GC processes, and compares serial, parallel, and concurrent collectors to help developers choose the optimal GC strategy.
Generational GCJVMgarbage collection
0 likes · 11 min read
