Skip to content
Tagged articles

garbage collection

500 articles · Page 4 of 5
JavaEdge
JavaEdge
Oct 26, 2021 · Fundamentals

Master Java Garbage Collection: Visual Guide to Algorithms and Roots

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
Master Java Garbage Collection: Visual Guide to Algorithms and Roots
Programmer DD
Programmer DD
Oct 19, 2021 · Backend Development

How the Three‑Color Marking Algorithm Powers Java’s CMS and G1 Garbage Collectors

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.

CMSConcurrent MarkingG1
0 likes · 17 min read
How the Three‑Color Marking Algorithm Powers Java’s CMS and G1 Garbage Collectors
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 13, 2021 · Fundamentals

JVM Core Concepts: Memory Areas, Class Loading, Object Creation, and Garbage Collection

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.

Class LoadingJVMJava
0 likes · 51 min read
JVM Core Concepts: Memory Areas, Class Loading, Object Creation, and Garbage Collection
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Sep 30, 2021 · Mobile Development

Understanding ART Runtime GC Configuration and Heap Layout on Android R

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.

ARTAndroidHeap Layout
0 likes · 19 min read
Understanding ART Runtime GC Configuration and Heap Layout on Android R
21CTO
21CTO
Sep 29, 2021 · Backend Development

Why Java 17 Is the Fastest Yet and What to Expect from Java 18

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.

JDK 17JDK 18Java
0 likes · 6 min read
Why Java 17 Is the Fastest Yet and What to Expect from Java 18
21CTO
21CTO
Sep 24, 2021 · Backend Development

Is Java 17 Worth the Upgrade? Performance Benchmarks and Free JDK Insights

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.

Free LicenseJDKJava
0 likes · 10 min read
Is Java 17 Worth the Upgrade? Performance Benchmarks and Free JDK Insights
Wukong Talks Architecture
Wukong Talks Architecture
Sep 23, 2021 · Backend Development

Comprehensive JVM Garbage Collection Interview Questions and Answers

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.

InterviewJVMJava
0 likes · 27 min read
Comprehensive JVM Garbage Collection Interview Questions and Answers
Java Architecture Diary
Java Architecture Diary
Sep 16, 2021 · Fundamentals

Shenandoah GC’s Concurrent Thread Stack Processing Slashes Pause Times to Sub‑millisecond in JDK 17

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.

Concurrent GCJDK 17Java performance
0 likes · 12 min read
Shenandoah GC’s Concurrent Thread Stack Processing Slashes Pause Times to Sub‑millisecond in JDK 17
WeDoctor Frontend Technology
WeDoctor Frontend Technology
Sep 15, 2021 · Fundamentals

Ace JavaScript Interviews: Master Variables, Types, Memory & Garbage Collection

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.

Deep CopyInterview Preparationgarbage collection
0 likes · 14 min read
Ace JavaScript Interviews: Master Variables, Types, Memory & Garbage Collection
Architect
Architect
Sep 9, 2021 · Fundamentals

Understanding JVM Memory Structure: Areas, Allocation, and Tuning

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.

HeapJVMJava
0 likes · 16 min read
Understanding JVM Memory Structure: Areas, Allocation, and Tuning
vivo Internet Technology
vivo Internet Technology
Sep 2, 2021 · Backend Development

Full-Link Tracing in Node.js Applications: Async Hooks and Zone-Context Design

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.

Full‑Link TracingNode.jsPerformance Monitoring
0 likes · 19 min read
Full-Link Tracing in Node.js Applications: Async Hooks and Zone-Context Design
Architect's Tech Stack
Architect's Tech Stack
Aug 24, 2021 · Backend Development

Common JVM Startup Parameters and Their Usage

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.

JVMJavagarbage collection
0 likes · 11 min read
Common JVM Startup Parameters and Their Usage
Tencent Cloud Developer
Tencent Cloud Developer
Aug 5, 2021 · Fundamentals

Java vs Go: A Comparative Analysis of Garbage Collection Algorithms

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.

Generational CollectionGo GCJVM
0 likes · 14 min read
Java vs Go: A Comparative Analysis of Garbage Collection Algorithms
Tencent Cloud Developer
Tencent Cloud Developer
Aug 4, 2021 · Fundamentals

Golang Garbage Collection: Algorithms, Memory Management, and Evolution

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.

Concurrent MarkingGoRuntime
0 likes · 30 min read
Golang Garbage Collection: Algorithms, Memory Management, and Evolution
Tencent Cloud Developer
Tencent Cloud Developer
Aug 3, 2021 · Backend Development

Overview of Java Garbage Collection Algorithms and Memory Management

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
Overview of Java Garbage Collection Algorithms and Memory Management
Code Ape Tech Column
Code Ape Tech Column
Aug 3, 2021 · Backend Development

Why Does Java Leak Memory? Deep Dive into Causes and Prevention

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.

Best PracticesJavaMemory Leak
0 likes · 18 min read
Why Does Java Leak Memory? Deep Dive into Causes and Prevention
Java Architect Essentials
Java Architect Essentials
Aug 2, 2021 · Backend Development

Java Garbage Collection, JVM Memory Model, Concurrency Locks, Thread Pools and Distributed Locking

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.

ConcurrencyDistributed LockJVM
0 likes · 23 min read
Java Garbage Collection, JVM Memory Model, Concurrency Locks, Thread Pools and Distributed Locking
Java Architect Essentials
Java Architect Essentials
Jul 25, 2021 · Backend Development

How I Cut Full GC Frequency by 80%: A JVM Tuning Case Study

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.

BackendJVMMemory Leak
0 likes · 10 min read
How I Cut Full GC Frequency by 80%: A JVM Tuning Case Study
Tencent Cloud Middleware
Tencent Cloud Middleware
Jun 17, 2021 · Fundamentals

How Tencent Kona JDK 11 ZGC Delivers Millisecond‑Level GC Pauses for Real‑Time Services

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.

Java performanceTencent Kona JDKZGC
0 likes · 28 min read
How Tencent Kona JDK 11 ZGC Delivers Millisecond‑Level GC Pauses for Real‑Time Services
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 7, 2021 · Fundamentals

Understanding Java Garbage Collection: Reference Counting, Reachability Analysis, and Major GC Algorithms

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
Understanding Java Garbage Collection: Reference Counting, Reachability Analysis, and Major GC Algorithms
Programmer DD
Programmer DD
May 27, 2021 · Operations

How We Cut Full GC Frequency from 40×/Day to Once Every 10 Days

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.

Full GCJVMJava
0 likes · 12 min read
How We Cut Full GC Frequency from 40×/Day to Once Every 10 Days
Programmer DD
Programmer DD
May 23, 2021 · Operations

How I Cut Full GC Frequency from 40 to 1 in 10 Days: A JVM Tuning Journey

Over a month of systematic investigation, the author reduced Full GC occurrences on a 2‑core, 4 GB Java server cluster from 40 times a day to roughly once every ten days by adjusting heap settings, fixing a memory‑leak caused by an anonymous listener, and tuning Metaspace and CMS thresholds, ultimately achieving stable performance and lower latency.

JVMJavaMemory Leak
0 likes · 11 min read
How I Cut Full GC Frequency from 40 to 1 in 10 Days: A JVM Tuning Journey
MaGe Linux Operations
MaGe Linux Operations
May 15, 2021 · Fundamentals

How Python’s Garbage Collector Works: Reference Counting, Mark‑Sweep, and Generational GC Explained

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
How Python’s Garbage Collector Works: Reference Counting, Mark‑Sweep, and Generational GC Explained
DeWu Technology
DeWu Technology
Apr 29, 2021 · Backend Development

JVM Garbage Collection: CMS Principles and Tuning

Understanding JVM garbage collection with the CMS collector involves grasping class‑loader hierarchies, memory regions such as Young, Old and Metaspace, the multithreaded ParNew young collector, CMS’s four‑phase mark‑sweep‑compact cycle, and applying tuning parameters—like survivor ratios, tenuring thresholds, and concurrent marking options—to minimize stop‑the‑world pauses and full GCs on typical 4‑core, 8 GB servers.

CMSJVMJava
0 likes · 18 min read
JVM Garbage Collection: CMS Principles and Tuning
Programmer DD
Programmer DD
Apr 27, 2021 · Fundamentals

Why Setting Unused Objects to null Can Actually Help Java GC – A Deep Dive

This article explains the misconception that null‑assigning unused objects always improves Java garbage collection, demonstrates with concrete JVM examples how stack references affect object reachability, and shows how explicit null or variable reuse can free memory more effectively.

JVMJavagarbage collection
0 likes · 10 min read
Why Setting Unused Objects to null Can Actually Help Java GC – A Deep Dive
Tencent Cloud Middleware
Tencent Cloud Middleware
Apr 21, 2021 · Backend Development

How Pulsar Stores Messages and How BookKeeper’s GC Keeps Them Clean

This article explains Apache Pulsar’s message storage architecture in BookKeeper, details the ledger and entry lifecycle, describes the multi‑layer caching read path, and outlines BookKeeper’s garbage‑collection process along with practical operational tips for avoiding disk‑heavy scenarios.

Apache PulsarBackendBookKeeper
0 likes · 12 min read
How Pulsar Stores Messages and How BookKeeper’s GC Keeps Them Clean
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 19, 2021 · Backend Development

Comprehensive Guide to Java JVM: Architecture, Class Loading, Garbage Collection, and Performance Tuning

This article provides an in‑depth overview of the Java Virtual Machine, covering JDK/JRE/JVM relationships, compilation process, class loading mechanisms, the parent‑delegation model, runtime memory areas, garbage collection algorithms and collectors, and practical JVM performance tuning tips for backend developers.

Class LoadingJVMJava
0 likes · 50 min read
Comprehensive Guide to Java JVM: Architecture, Class Loading, Garbage Collection, and Performance Tuning
Yuewen Technology
Yuewen Technology
Apr 16, 2021 · Backend Development

Why G1 Is the Future Garbage Collector for High‑Throughput Java Services

This article examines how Oracle's G1 garbage collector, the default since JDK 9, outperforms the traditional CMS collector in multi‑core, large‑memory environments through parallelism, space integration, predictive pause models, and real‑world performance testing on Yuewen's licensing service.

G1GCJVMJava
0 likes · 9 min read
Why G1 Is the Future Garbage Collector for High‑Throughput Java Services
Miss Fresh Tech Team
Miss Fresh Tech Team
Apr 16, 2021 · Backend Development

Why G1GC? Understanding Soft Real‑Time and Pause‑Time Prediction in Java

This article explains the evolution of garbage collection, why G1GC is chosen for low‑latency high‑availability Java services, how it achieves soft real‑time guarantees, the internal heap and region structures, concurrent marking, SATB, remembered sets, and the algorithms used to predict pause times.

G1GCJVMPause Prediction
0 likes · 20 min read
Why G1GC? Understanding Soft Real‑Time and Pause‑Time Prediction in Java
ByteFE
ByteFE
Apr 14, 2021 · Frontend Development

Understanding JavaScript Memory Leaks and Garbage Collection

This article explains JavaScript memory leaks, covering their definition, how JS manages stack and heap memory, automatic garbage collection, Chrome DevTools profiling techniques, and common leak patterns such as improper closures, global variables, detached DOM nodes, console logging, and forgotten timers, with detection and mitigation strategies.

Chrome DevToolsJavaScriptMemory Leak
0 likes · 17 min read
Understanding JavaScript Memory Leaks and Garbage Collection
Top Architect
Top Architect
Apr 8, 2021 · Fundamentals

Java 8 Memory Structure Overview

This article explains the Java 8 memory architecture, detailing the differences between JVM-managed memory and native memory, describing each runtime data area such as the program counter, JVM stack, native method stack, heap, method area, and direct memory, and answering common questions about variable storage, native methods, literals and symbolic references.

Java8Runtime Data Areagarbage collection
0 likes · 13 min read
Java 8 Memory Structure Overview
DeWu Technology
DeWu Technology
Apr 2, 2021 · Fundamentals

How Android’s ART Runtime Manages Heap Memory: A Deep Dive into GC Structures

This article explains why reading the ART virtual‑machine source is valuable, compares Dalvik and ART, outlines the GC source hierarchy, details the Space class architecture—including accounting, allocator, collector, and specific spaces like LargeObjectSpace, BumpPointerSpace, and RegionSpace—then analyzes heap construction, PreZygoteFork processing, memory‑map layout, and the full Java‑object allocation flow in ART.

ARTAndroidHeap
0 likes · 43 min read
How Android’s ART Runtime Manages Heap Memory: A Deep Dive into GC Structures
Java Backend Technology
Java Backend Technology
Mar 28, 2021 · Backend Development

Hidden Java Memory Leaks: 8 Common Pitfalls and How to Fix Them

This article explains eight typical Java memory‑leak scenarios—including unclosed resources, missing equals/hashCode, non‑static inner classes, overridden finalize, String.intern misuse, ThreadLocal traps, and static variables in web containers—provides code examples for each, and offers practical mitigation strategies.

FinalizeJavaMemory Leak
0 likes · 11 min read
Hidden Java Memory Leaks: 8 Common Pitfalls and How to Fix Them
Python Programming Learning Circle
Python Programming Learning Circle
Mar 20, 2021 · Fundamentals

Understanding Python Object Memory Management and Garbage Collection

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
Understanding Python Object Memory Management and Garbage Collection
Selected Java Interview Questions
Selected Java Interview Questions
Mar 11, 2021 · Fundamentals

Understanding ZGC: A Low‑Latency Garbage Collector for Java

The article explains ZGC, Oracle's low‑latency Java garbage collector introduced in JDK 11, covering its dynamic region layout, colored pointer technique, tri‑color marking, memory multi‑mapping, read barriers, operation phases, performance characteristics, and its main drawback of floating garbage.

Concurrent MarkingJavaZGC
0 likes · 11 min read
Understanding ZGC: A Low‑Latency Garbage Collector for Java
Byte Quality Assurance Team
Byte Quality Assurance Team
Mar 10, 2021 · Fundamentals

Understanding Python Garbage Collection and Reference Counting

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
Understanding Python Garbage Collection and Reference Counting
Big Data Technology Architecture
Big Data Technology Architecture
Mar 9, 2021 · Databases

Evaluating ZGC vs G1 GC Performance in HBase Clusters

This article examines the challenges of GC pauses in low‑latency HBase services, explains ZGC’s fully concurrent architecture and key techniques such as colored pointers and read barriers, and presents experimental comparisons of ZGC and G1 GC using YCSB benchmarks, highlighting latency, throughput and CPU usage differences.

G1GCHBaseYCSB
0 likes · 18 min read
Evaluating ZGC vs G1 GC Performance in HBase Clusters
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Mar 3, 2021 · Frontend Development

Mastering JavaScript Memory Management: GC Algorithms and Performance Tips

Understanding how JavaScript manages memory, this article explains garbage collection concepts such as Stop‑The‑World pauses, reference counting, mark‑sweep, mark‑compact, incremental marking, and V8’s generational strategies, while offering practical code examples and optimization techniques to prevent leaks and improve performance.

JavaScriptV8garbage collection
0 likes · 14 min read
Mastering JavaScript Memory Management: GC Algorithms and Performance Tips
Code Ape Tech Column
Code Ape Tech Column
Feb 26, 2021 · Operations

How Memory Tweaks Transform IntelliJ IDEA Performance: A Real‑World Test

This article presents a systematic experiment that compares four different IntelliJ IDEA memory configurations on a MacBook Pro, measuring IDE startup time, project loading speed, and JVM garbage‑collection metrics with jstat to identify the most efficient setup for large Java monoliths and micro‑service projects.

IDE performanceIntelliJ IDEAJVM memory tuning
0 likes · 11 min read
How Memory Tweaks Transform IntelliJ IDEA Performance: A Real‑World Test
Selected Java Interview Questions
Selected Java Interview Questions
Feb 7, 2021 · Fundamentals

Common Causes of Java Memory Leaks and How to Fix Them

This article explains the typical sources of Java OutOfMemoryError—including static collections, unclosed connections, improper variable scopes, inner‑class references, hash value changes, cache misuse, and lingering listeners—and provides code examples and solutions to prevent memory leaks.

JavaOutOfMemoryErrorWeakHashMap
0 likes · 10 min read
Common Causes of Java Memory Leaks and How to Fix Them
Java Interview Crash Guide
Java Interview Crash Guide
Jan 28, 2021 · Backend Development

Why Adding More JVM Memory Won’t Fix Performance: Real Tuning Strategies

Even though many joke that simply increasing JVM heap solves performance issues, this article explains why blind memory expansion often worsens latency in high‑concurrency scenarios and presents concrete tuning strategies such as adjusting young generation size, reducing stack memory, and monitoring GC metrics.

JVMMemory Tuninggarbage collection
0 likes · 7 min read
Why Adding More JVM Memory Won’t Fix Performance: Real Tuning Strategies
Java Interview Crash Guide
Java Interview Crash Guide
Jan 14, 2021 · Backend Development

Mastering JVM: Memory Areas, GC, and Class Loading Explained

This comprehensive guide walks through the Java Virtual Machine's runtime data areas, memory model, heap layout, garbage‑collection mechanisms, HotSpot internals, performance tuning flags, and class‑loading process, providing developers with the essential knowledge to optimize Java applications.

Class LoadingJVMJava Memory Model
0 likes · 29 min read
Mastering JVM: Memory Areas, GC, and Class Loading Explained
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 10, 2021 · Fundamentals

Understanding the JVM Memory Model, Garbage Collection Algorithms, and Performance Optimizations

This comprehensive guide explains the JVM memory layout, object allocation, garbage collection mechanisms such as mark‑sweep, copying, and mark‑compact, details GC roots, reference types, collector types, tuning parameters, and related Java performance tools, providing practical code examples and diagrams.

JVMJavaPerformance Tuning
0 likes · 42 min read
Understanding the JVM Memory Model, Garbage Collection Algorithms, and Performance Optimizations
Big Data Technology & Architecture
Big Data Technology & Architecture
Jan 2, 2021 · Fundamentals

Understanding G1 Garbage Collector: Architecture, Algorithms, and Tuning

This article explains the different types of Java garbage collectors, focuses on the G1 (Garbage‑First) collector’s region‑based architecture, key data structures and algorithms such as TLAB, PLAB, CSet, Card Table, RSet, and SATB, and provides detailed log analysis and tuning recommendations to improve pause times and throughput.

G1 GCJVMJava
0 likes · 37 min read
Understanding G1 Garbage Collector: Architecture, Algorithms, and Tuning
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Dec 31, 2020 · Fundamentals

Unlocking JVM Secrets: Memory Leaks, GC, Class Loading and Performance Tuning

This comprehensive guide explores Java's JVM internals, covering memory leaks, data type sizes, differences between Serial and Parallel GC, reference types, compressed OOPs, JVM bitness detection, heap limits, JRE/JDK/JVM/JIT distinctions, memory regions, garbage collection algorithms, class loading mechanisms, and practical tuning commands and tools, providing developers with deep insights into Java performance and memory management.

Class LoadingJavaPerformance Tuning
0 likes · 63 min read
Unlocking JVM Secrets: Memory Leaks, GC, Class Loading and Performance Tuning
Code Ape Tech Column
Code Ape Tech Column
Dec 25, 2020 · Fundamentals

Inside the JVM: Unraveling Memory Areas, GC, and Class Loading

This article provides a comprehensive overview of the Java Virtual Machine, covering its runtime data areas, the Java Memory Model, heap organization, garbage‑collection algorithms, HotSpot implementation details, JVM tuning parameters, and the class‑loading mechanism.

Class LoadingJMMJVM
0 likes · 29 min read
Inside the JVM: Unraveling Memory Areas, GC, and Class Loading
政采云技术
政采云技术
Dec 22, 2020 · Frontend Development

V8 Engine Garbage Collection and Memory Allocation

This article explains the architecture of browser engines, the distinction between stack and heap memory, V8's generational garbage collection strategies—including the Scavenge algorithm for the young generation and mark‑sweep/mark‑compact for the old generation—along with optimizations such as write barriers, incremental marking, and parallel/concurrent collection.

JavaScript engineV8garbage collection
0 likes · 13 min read
V8 Engine Garbage Collection and Memory Allocation
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 16, 2020 · Fundamentals

Exploring Modern Java Garbage Collectors: G1, ZGC, and Shenandoah

This article examines the evolution of Java garbage collectors, detailing the design and operation of G1, ZGC, and Shenandoah, and explains key concepts such as generational collection, write and read barriers, SATB, RSet, and multi‑view mapping with illustrative code and diagrams.

Concurrent AlgorithmsG1Java
0 likes · 27 min read
Exploring Modern Java Garbage Collectors: G1, ZGC, and Shenandoah
Qunar Tech Salon
Qunar Tech Salon
Nov 13, 2020 · Fundamentals

Understanding JVM Garbage Collectors: Memory Models, Generational and Region-Based Designs, and Low‑Latency Collectors

This article examines the evolution and classification of HotSpot JVM garbage collectors, explaining the performance triangle of heap usage, throughput and pause time, and detailing generational, region‑based, and low‑latency collectors such as G1, Shenandoah, and ZGC with their design principles and benchmark results.

G1JVMShenandoah
0 likes · 19 min read
Understanding JVM Garbage Collectors: Memory Models, Generational and Region-Based Designs, and Low‑Latency Collectors
Meituan Technology Team
Meituan Technology Team
Nov 12, 2020 · Backend Development

Comprehensive Guide to Java CMS Garbage Collection Issues and Optimization

This guide explains Java HotSpot CMS garbage collection fundamentals, common problem scenarios like space shock and premature promotion, systematic root‑cause analysis using logs and tools, and practical optimization tactics such as stabilizing heap size, tuning CMS flags, monitoring off‑heap memory, and migrating to newer collectors.

CMSJVMJava
0 likes · 69 min read
Comprehensive Guide to Java CMS Garbage Collection Issues and Optimization
High Availability Architecture
High Availability Architecture
Nov 5, 2020 · Backend Development

Why We Chose Java for Our High‑Frequency Trading Application

The article explains how a high‑frequency trading firm evaluated Java versus C++ for ultra‑low‑latency trading, discusses the challenges of JVM JIT compilation and garbage‑collection pauses, and shows how Azul Zing’s C4 collector delivers near‑C++ latency while preserving Java’s development productivity.

Azul ZingJVMJava
0 likes · 11 min read
Why We Chose Java for Our High‑Frequency Trading Application
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 5, 2020 · Fundamentals

Why Understanding JVM Garbage Collection Algorithms Is Essential for Advanced Java Developers

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
Why Understanding JVM Garbage Collection Algorithms Is Essential for Advanced Java Developers
IT Xianyu
IT Xianyu
Nov 5, 2020 · Fundamentals

Four Types of References in Java and Their Usage

This article explains Java's four reference types—strong, soft, weak, and phantom—detailing their purposes, behavior during garbage collection, and practical code examples that demonstrate how each reference influences object lifecycle and memory management.

JavaPhantomReferenceReference Types
0 likes · 9 min read
Four Types of References in Java and Their Usage
Programmer DD
Programmer DD
Oct 22, 2020 · Backend Development

What’s New in JDK 16? 8 Key Feature Proposals You Should Know

The article outlines eight official JDK 16 proposals—including ZGC thread‑stack removal, flexible metaspace, C++14 support, incubator vector API, Windows/AArch64 ports, Alpine Linux builds, and the migration of the OpenJDK source from Mercurial to GitHub—while noting JDK 16’s short‑term support and the prevalence of JDK 8 among developers.

C++14JDK 16Java
0 likes · 4 min read
What’s New in JDK 16? 8 Key Feature Proposals You Should Know
58 Tech
58 Tech
Oct 21, 2020 · Backend Development

Understanding Java Memory Pools: Netty’s Implementation and Underlying Theory

This article revisits memory allocation and reclamation concepts by examining Java's Netty memory pool implementation, its theoretical basis in jemalloc, and practical design choices such as arena allocation, thread‑local caches, pool chunks, sub‑pages, and multi‑threaded performance considerations.

JavaNettygarbage collection
0 likes · 21 min read
Understanding Java Memory Pools: Netty’s Implementation and Underlying Theory
Xianyu Technology
Xianyu Technology
Sep 23, 2020 · Mobile Development

Detecting Memory Leaks in Flutter via Rendering Tree Analysis

By tracking the discrepancy between the number of EngineLayer objects actually rendered each frame and the total EngineLayer instances retained in native memory, developers can detect and pinpoint Flutter memory leaks caused by lingering Dart references, using SceneBuilder monitoring and WeakPersistentHandle inspection.

DartFlutterMemory Leak
0 likes · 10 min read
Detecting Memory Leaks in Flutter via Rendering Tree Analysis
Watermelon Video Tech Team
Watermelon Video Tech Team
Aug 19, 2020 · Mobile Development

Analyzing Native Memory OOM in Android Camera Implementations and Effective Mitigation Strategies

This article investigates native memory out‑of‑memory crashes on certain Android devices caused by excessive CameraMetadata allocations, explains how delayed finalization and GC timing exacerbate the issue, and proposes proactive memory release and GC triggering techniques that dramatically reduce crash rates.

AndroidCameraNative Memory
0 likes · 13 min read
Analyzing Native Memory OOM in Android Camera Implementations and Effective Mitigation Strategies
High Availability Architecture
High Availability Architecture
Aug 11, 2020 · Operations

Understanding and Optimizing ZGC (Z Garbage Collector) for Low‑Latency Java Services

This article examines the Z Garbage Collector (ZGC) introduced in JDK 11, detailing its low‑pause design goals, underlying concurrent marking‑copy algorithm, colored pointer and read‑barrier techniques, practical tuning parameters, real‑world case studies, and the performance impact of upgrading from CMS/G1 to ZGC in high‑throughput, low‑latency services.

JVMJavaZGC
0 likes · 28 min read
Understanding and Optimizing ZGC (Z Garbage Collector) for Low‑Latency Java Services
Wukong Talks Architecture
Wukong Talks Architecture
Aug 7, 2020 · Fundamentals

JVM Interview Questions and Java Mind Map Resources

This article presents a comprehensive collection of JVM interview questions covering memory areas, garbage collection, class loading, and performance tuning, along with eleven detailed Java mind‑map images that visually summarize core concepts such as the JVM architecture, GC algorithms, and thread management.

Class LoadingInterviewJVM
0 likes · 8 min read
JVM Interview Questions and Java Mind Map Resources
Meituan Technology Team
Meituan Technology Team
Aug 6, 2020 · Backend Development

ZGC: Principles, Tuning Practices, and Production Upgrade Experience

The article explains how Meituan’s risk‑control platform eliminated frequent 40 ms CMS pauses by adopting JDK 11’s ZGC—detailing its concurrent mark‑copy design, practical tuning parameters, real‑world case fixes, and measured latency reductions of up to 74 % while noting trade‑offs.

JDK11JavaPerformance Tuning
0 likes · 27 min read
ZGC: Principles, Tuning Practices, and Production Upgrade Experience
Ctrip Technology
Ctrip Technology
Jul 16, 2020 · Databases

Design and Implementation of Bidirectional Redis Synchronization Across IDC: Cycle Break, LWW, Vector Clock, Tombstone, GC, and Expire

This article details Ctrip's practical design and implementation of a bidirectional Redis synchronization system across data centers, covering replication loop breaking, conflict resolution with Last Write Wins and Vector Clocks, tombstone handling, garbage collection strategies, and expiration policies to ensure data consistency.

CRDTData ConsistencyRedis
0 likes · 12 min read
Design and Implementation of Bidirectional Redis Synchronization Across IDC: Cycle Break, LWW, Vector Clock, Tombstone, GC, and Expire
Top Architect
Top Architect
Jul 11, 2020 · Operations

7 Key Performance Metrics for Application Monitoring and Their Recommended Tools

The article outlines seven essential performance metrics—response time and throughput, average load, error rate, GC pause time, business indicators, uptime, and log size—explaining their significance for application health and recommending popular monitoring tools for each metric.

Performance MonitoringResponse Timeerror rate
0 likes · 6 min read
7 Key Performance Metrics for Application Monitoring and Their Recommended Tools
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 5, 2020 · Fundamentals

Understanding JVM Runtime Data Areas and Memory Management

This article provides a comprehensive overview of the Java Virtual Machine's runtime data areas—including the program counter, JVM stack, native method stack, heap, and method area—explaining their structures, lifecycles, related JVM flags, garbage‑collection strategies, TLAB, and escape‑analysis optimizations.

JVMJavaRuntime Data Area
0 likes · 42 min read
Understanding JVM Runtime Data Areas and Memory Management
FunTester
FunTester
Jun 25, 2020 · Fundamentals

Mastering JDK8 Garbage Collection: Visual Cheat Sheet and Tuning Guide

This article presents a comprehensive overview of JDK8's garbage collection mechanisms, detailing memory regions, available collectors, key tuning parameters, thread settings, and practical commands, complemented by eight illustrative diagrams and a downloadable PDF cheat sheet for quick reference.

GC tuningJDK8JVM
0 likes · 7 min read
Mastering JDK8 Garbage Collection: Visual Cheat Sheet and Tuning Guide