Tagged articles
GC algorithms
24 articles · Page 1 of 1
This article explains the three fundamental garbage‑collection algorithms (Mark‑Sweep, Copying, Mark‑Compact), the three generational hypotheses, the structure and rules of the young generation, the distinctions among Minor, Major and Full GCs, and how remembered sets and card tables efficiently handle cross‑generation references in the JVM.
Card TableGC algorithmsGenerational model
0 likes · 19 min read

This article provides a comprehensive overview of Java garbage collection, covering the principles of reference counting and reachability analysis, detailing major GC algorithms such as mark‑sweep, copying, and mark‑compact, explaining object allocation strategies, and reviewing traditional and modern collectors like Serial, CMS, and G1, with practical tuning tips for each.
GC algorithmsJVMgarbage collection
0 likes · 19 min read

This article explains Go's memory management by detailing stack and heap differences, describing classic and modern garbage‑collection algorithms, tracing the evolution of Go's GC from version 1.3 to 1.8, and outlining a complete GC cycle with practical code examples.
ConcurrencyGC algorithmsGo
0 likes · 31 min read

This article explains the fundamentals of garbage collection, compares manual and automatic memory management, outlines common GC algorithms, and provides practical guidance on performance analysis, tool selection, and optimization techniques to improve application responsiveness and resource utilization.
GC algorithmsResource Utilizationgarbage collection
0 likes · 22 min read

This article explains why garbage collection (GC) is essential, defines key GC terminology, compares performance metrics, and provides a detailed overview of seven common GC algorithms—including mark‑sweep, reference counting, copying, mark‑compact, conservative, generational, and incremental GC—along with their advantages, disadvantages, and typical improvements.
GC algorithmsmemory managementsoftware fundamentals
0 likes · 47 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

The article offers a thorough overview of Java 8 memory management, detailing JVM memory regions, object eligibility, major garbage‑collection algorithms and generational models, comparing Serial, Parallel, CMS and G1 collectors, and presenting practical heap‑dump analysis techniques for diagnosing leaks and performance issues.
GC algorithmsHeap AnalysisJVM
0 likes · 29 min read

The article explains Dart VM’s generational garbage collection, detailing object allocation, the young‑generation Scavenge copying collector, old‑generation Mark‑Sweep and Mark‑Compact algorithms, safepoints, write‑barrier mechanics, debugging a write‑protect crash, and the importance of logging for memory‑management analysis.
DartGC algorithmsVM
0 likes · 33 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

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.
G1GC algorithmsJVM
0 likes · 19 min read

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.
CMSGC algorithmsJVM
0 likes · 19 min read

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.
GC algorithmsJVMJava
0 likes · 12 min read

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.
GC algorithmsJVMJava
0 likes · 16 min read

This article explains the JVM garbage collection mechanism, covering which memory areas are collected, how object reachability is determined, the main GC algorithms, generational collection theory, and JVM heap layout, providing essential knowledge for Java performance tuning.
GC algorithmsJVMJVM tuning
0 likes · 20 min read

This article explores the underlying principles of Java Virtual Machine garbage collection, detailing core concepts, classic algorithms, generational and incremental improvements, and the role of read/write barriers, helping developers grasp why mastering GC is a fundamental skill for high‑performance Java programming.
ConcurrencyGC algorithmsJVM
0 likes · 26 min read

This article explains Java garbage collection by outlining its purpose, the criteria for reclaimable objects through reference counting and reachability analysis, when collection occurs, and the main GC algorithms—including mark‑sweep, copying, mark‑compact, and generational collection—along with common JVM collectors.
GC algorithmsJVMJava
0 likes · 9 min read

This article explains Java garbage collection fundamentals, detailing JVM memory layout, key -X and -XX parameters, the mechanisms of object survival, and the main GC algorithms—Mark‑Sweep, Copying, Mark‑Compact, and generational collection—providing clear diagrams and interview‑ready insights.
GC algorithmsInterview PreparationJVM
0 likes · 9 min read

This article provides a comprehensive overview of the JVM memory model, garbage collection algorithms, various collectors and their trade‑offs, class loading steps, object lifecycle, escape analysis, and practical tuning commands for optimizing Java applications.
GC algorithmsJVMJava
0 likes · 14 min read

Java’s garbage collection, a critical yet often overlooked feature, encompasses various algorithms such as reference counting, reachability analysis, mark‑sweep, copying, and generational collection, each with distinct mechanisms, trade‑offs, and impacts on memory regions like Eden, Survivor, and Old spaces.
GC algorithmsJVMJava
0 likes · 15 min read

This article examines the pause behavior of various OpenJDK garbage collectors by running a memory‑allocation benchmark, presenting detailed GC logs for G1, Parallel, CMS, Shenandoah, and Epsilon, and drawing conclusions on how to choose the appropriate collector for a given workload.
GC algorithmsJVMJava
0 likes · 11 min read

This article provides a comprehensive overview of Java's garbage collection mechanism, memory regions, object access methods, allocation strategies, GC algorithms, and the various collectors used in the HotSpot JVM, helping developers understand and optimize Java memory usage.
GC algorithmsJVMgarbage collection
0 likes · 22 min read

This article explains Java's automatic garbage collection, describes common GC algorithms such as reference counting, mark‑sweep, copying, mark‑compact, incremental and generational collection, classifies JVM collectors, compares their performance impact, and summarizes key JVM GC parameters.
GC algorithmsJVMJava
0 likes · 28 min read

This article explores Java's garbage collection mechanisms, detailing why memory reclamation is essential, the design considerations, various algorithms such as mark‑sweep, copy, and compact, the roles of different collectors like Serial, Parallel, CMS, and G1, and how they impact performance.
GC algorithmsJVMJava
0 likes · 8 min read

This article explains Java's memory model and garbage collection mechanisms, covering reference counting, tracing collectors, copying and mark‑sweep algorithms, parallel and concurrent collectors, generational GC, and compression techniques, while discussing their trade‑offs, tuning considerations, and impact on application performance.
GC algorithmsJVMJava
0 likes · 25 min read
