BestHub
Sign in
Tagged articles

Garbage Collection

504 articles · Page 4 of 6
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 MarkingGarbage CollectionGo
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 AlgorithmsGarbage CollectionJVM
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.

Garbage Collectionbest practicesjava
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.

Garbage CollectionJVMLock
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.

Garbage CollectionJVMOperations
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.

Garbage CollectionJava performanceTencent Kona JDK
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.

Garbage CollectionGenerational GCMark‑Sweep
0 likes · 7 min read
Understanding Java Garbage Collection: Reference Counting, Reachability Analysis, and Major GC Algorithms
Selected Java Interview Questions
Selected Java Interview Questions
Jun 7, 2021 · Backend Development

Common JVM Garbage Collectors: Characteristics, Use Cases, and Tuning Parameters

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.

Garbage CollectionJVMMemory Management
0 likes · 13 min read
Common JVM Garbage Collectors: Characteristics, Use Cases, and Tuning Parameters
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 GCGarbage CollectionJVM
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.

Garbage CollectionJVMjava
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.

Garbage CollectionGenerational GCMark‑Sweep
0 likes · 47 min read
How Python’s Garbage Collector Works: Reference Counting, Mark‑Sweep, and Generational GC Explained
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 15, 2021 · Backend Development

JVM Tuning Guide: Understanding GC, Memory Model, and Configuration Options

This article provides a comprehensive guide to JVM performance tuning, covering the JVM architecture, runtime data areas, various garbage collectors, configuration flags for heap and GC settings, and practical recommendations for selecting the optimal GC strategy based on workload characteristics.

Garbage CollectionJVMbackend development
0 likes · 6 min read
JVM Tuning Guide: Understanding GC, Memory Model, and Configuration Options
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 7, 2021 · Fundamentals

The Life Cycle of Java Objects: From Allocation to Old Generation

This article uses a real‑world recommendation system case to explain how Java objects are created in the young generation, survive multiple young GCs, and are promoted to the old generation under various conditions such as repeated GC cycles, dynamic age thresholds, and space‑guarantee mechanisms.

Garbage CollectionJVMMemory Management
0 likes · 7 min read
The Life Cycle of Java Objects: From Allocation to Old Generation
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.

CMSGarbage CollectionJVM
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.

Garbage CollectionJVMMemory Management
0 likes · 10 min read
Why Setting Unused Objects to null Can Actually Help Java GC – A Deep Dive
Code Ape Tech Column
Code Ape Tech Column
Apr 25, 2021 · Operations

JVM Garbage Collection Tuning: Reducing FullGC Frequency and Improving Throughput

This article documents a month-long JVM garbage‑collection tuning effort on a 2‑core, 4 GB server cluster, detailing initial problems with frequent FullGC, successive configuration adjustments, memory‑leak investigations, and the final optimizations that cut FullGC occurrences and significantly improved overall throughput.

FullGCGarbage CollectionJVM
0 likes · 10 min read
JVM Garbage Collection Tuning: Reducing FullGC Frequency and Improving Throughput
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 PulsarBookKeeperGarbage Collection
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 LoadingGarbage CollectionJVM
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.

G1GCGarbage CollectionJVM
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.

G1GCGarbage CollectionJVM
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 DevToolsGarbage CollectionJavaScript
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.

Garbage CollectionJava8Runtime Data Area
0 likes · 13 min read
Java 8 Memory Structure Overview
Senior Brother's Insights
Senior Brother's Insights
Apr 6, 2021 · Fundamentals

Do Objects Move in Memory During JVM Garbage Collection? Handles vs Direct Pointers Explained

This article explores how the JVM updates object references during garbage collection, compares handle‑based and direct‑pointer implementations, demonstrates why the default toString output shows a hashcode rather than a real address, and shows how to obtain the actual memory address using the JOL library.

Garbage CollectionHandle vs PointerJOL
0 likes · 7 min read
Do Objects Move in Memory During JVM Garbage Collection? Handles vs Direct Pointers Explained
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.

ARTAndroidGarbage Collection
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.

Garbage CollectionThreadLocalTomcat
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.

Garbage CollectionGenerational GCMemory Management
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 MarkingGarbage CollectionZGC
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.

Garbage CollectionGenerational GCreference-counting
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.

G1GCGarbage CollectionHBase
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.

Garbage CollectionJavaScriptMemory Management
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.

Garbage CollectionIDE performanceIntelliJ IDEA
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.

Garbage CollectionOutOfMemoryErrorWeakHashMap
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.

Garbage CollectionJVMMemory Tuning
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 LoadingGarbage CollectionJVM
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.

Garbage CollectionJVMMemory Management
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 GCGarbage CollectionJVM
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 LoadingGarbage CollectionMemory Management
0 likes · 63 min read
Unlocking JVM Secrets: Memory Leaks, GC, Class Loading and Performance Tuning
Top Architect
Top Architect
Dec 29, 2020 · Operations

Comprehensive Guide to Java Runtime Error Checking: CPU, Disk, Memory, GC, and Network Troubleshooting

This article provides a step‑by‑step guide for diagnosing Java production issues by systematically checking CPU usage, disk health, memory consumption, garbage‑collection behavior, and network problems using common Linux tools and JVM utilities such as ps, top, jstack, jstat, vmstat, iostat, free, jmap, and tcpdump.

CPUGarbage CollectionMemory
0 likes · 21 min read
Comprehensive Guide to Java Runtime Error Checking: CPU, Disk, Memory, GC, and Network Troubleshooting
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 LoadingGarbage CollectionJVM
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.

Garbage CollectionJavaScript engineMemory Management
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 AlgorithmsG1Garbage Collection
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.

G1Garbage CollectionJVM
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.

CMSGarbage CollectionJVM
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 ZingGarbage CollectionJVM
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.

GC AlgorithmsGarbage CollectionJVM
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.

Garbage CollectionMemory ManagementPhantomReference
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++14Garbage CollectionJDK 16
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.

Garbage CollectionMemory poolNetty
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.

DARTGarbage CollectionRendering Tree
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.

AndroidCameraGarbage Collection
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.

Garbage CollectionJVMZGC
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 LoadingGarbage CollectionInterview
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.

Garbage CollectionJDK11ZGC
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 ConsistencyGarbage Collection
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.

Garbage CollectionLog ManagementResponse Time
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.

Garbage CollectionJVMMemory Management
0 likes · 42 min read
Understanding JVM Runtime Data Areas and Memory Management
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 30, 2020 · Fundamentals

Understanding Java Garbage Collection: Goals, Algorithms, and Timing

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 AlgorithmsGarbage CollectionJVM
0 likes · 9 min read
Understanding Java Garbage Collection: Goals, Algorithms, and Timing
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 TuningGarbage CollectionJDK8
0 likes · 7 min read
Mastering JDK8 Garbage Collection: Visual Cheat Sheet and Tuning Guide
Programmer DD
Programmer DD
Jun 13, 2020 · Fundamentals

Mastering Java Garbage Collection: Goals, Tuning, and Collector Choices

This article explains Java HotSpot VM garbage‑collection ergonomics, detailing pause‑time and throughput goals, generational collection mechanics, default heap sizing, and how to select and tune Serial, Parallel, G1, and ZGC collectors for optimal performance.

G1 GCGC ErgonomicsGarbage Collection
0 likes · 32 min read
Mastering Java Garbage Collection: Goals, Tuning, and Collector Choices
Python Programming Learning Circle
Python Programming Learning Circle
Jun 3, 2020 · Fundamentals

Understanding CPython's Memory Management (Python 2.7)

This article explains how CPython implements its own memory‑management scheme—including the layered allocation model, pool and arena structures, block size classes, and reference‑count‑based reclamation—by dissecting the source code of Python 2.7’s obmalloc module.

CPythonGarbage CollectionMemory Management
0 likes · 23 min read
Understanding CPython's Memory Management (Python 2.7)
Programmer DD
Programmer DD
May 22, 2020 · Backend Development

Can ZGC Deliver Sub‑10ms Pauses for Massive Java Heaps?

This article explains the design goals, architecture, key features, tuning options, and version history of Java's Z Garbage Collector (ZGC), highlighting its sub‑10 ms pause times for terabyte‑scale heaps, its use of colored pointers and load barriers, and the trade‑offs in throughput and configuration.

Garbage CollectionJVMZGC
0 likes · 16 min read
Can ZGC Deliver Sub‑10ms Pauses for Massive Java Heaps?
Java Captain
Java Captain
May 20, 2020 · Fundamentals

Why Setting Unused Objects to null May Not Help Java Garbage Collection

This article explains, with concrete Java examples and JVM runtime‑stack analysis, why manually assigning null to objects that are out of scope does not always trigger earlier garbage collection, and how stack slot reuse can achieve the same effect without relying on a questionable practice.

Garbage CollectionJVMMemory Management
0 likes · 8 min read
Why Setting Unused Objects to null May Not Help Java Garbage Collection
Java Captain
Java Captain
May 16, 2020 · Fundamentals

Deep Dive into Java ThreadLocal: Data Structure, Hash Algorithm, Cleanup, and Usage

This article provides an in‑depth analysis of Java’s ThreadLocal mechanism, covering its weak‑reference key, internal ThreadLocalMap structure, hash algorithm, collision resolution, cleanup strategies, expansion logic, source code walkthroughs, and practical usage scenarios such as trace‑ID propagation in distributed systems.

Garbage CollectionThreadLocalThreadLocalMap
0 likes · 27 min read
Deep Dive into Java ThreadLocal: Data Structure, Hash Algorithm, Cleanup, and Usage
Java Architect Essentials
Java Architect Essentials
Apr 17, 2020 · Fundamentals

Comprehensive Java JVM Interview Guide: Architecture, Memory, GC, Class Loading, and Optimization

This article provides an extensive overview of Java Virtual Machine fundamentals for interview preparation, covering JVM components, runtime data areas, heap vs. stack memory, garbage collection mechanisms, algorithms, collectors, memory allocation strategies, class loading processes, and tuning tools.

Class LoadingGarbage CollectionJVM
0 likes · 31 min read
Comprehensive Java JVM Interview Guide: Architecture, Memory, GC, Class Loading, and Optimization
Sohu Tech Products
Sohu Tech Products
Apr 8, 2020 · Fundamentals

Design and Implementation of Go's Garbage Collector

This article provides an in‑depth overview of Go's garbage collector, covering its design principles, mark‑sweep algorithm, tri‑color abstraction, write‑barrier techniques, incremental and concurrent collection, evolution across Go versions, and detailed implementation details of marking, sweeping, and memory reclamation.

Garbage CollectionMemory Management
0 likes · 52 min read
Design and Implementation of Go's Garbage Collector
FunTester
FunTester
Apr 3, 2020 · Fundamentals

JVM Memory Model, GC Log Analysis, and Production Parameter Optimization

This article examines production JVM memory architecture, explains GC log generation and analysis, details the ParNew + CMS collector behavior, and provides practical parameter tuning recommendations to optimize heap size, young generation, and garbage collection for stable Java applications in production environments.

Garbage CollectionJVMMemory Management
0 likes · 10 min read
JVM Memory Model, GC Log Analysis, and Production Parameter Optimization
FunTester
FunTester
Apr 1, 2020 · Backend Development

Mastering JVM Performance: 6 Essential Parameters and GC Tuning Tips

Learn how to optimize Java applications by configuring six critical JVM parameters—including heap size, Metaspace limits, GC algorithm selection, logging, heap dumps, thread stack size, and network timeouts—while understanding their impact on performance, memory usage, and troubleshooting common out‑of‑memory issues.

Garbage CollectionHeap DumpJVM
0 likes · 9 min read
Mastering JVM Performance: 6 Essential Parameters and GC Tuning Tips
JavaEdge
JavaEdge
Mar 31, 2020 · Fundamentals

How to Pick the Best Java HotSpot GC: Serial, Parallel, CMS, G1 & ZGC

This guide compares the major HotSpot JVM garbage collectors—including Serial, ParNew, Parallel Scavenge, Parallel Old, CMS, G1, and ZGC—explaining their algorithms, threading models, typical use cases, key JVM flags, performance trade‑offs, and how to select the most suitable collector for different application workloads.

Garbage CollectionHotSpotJVM
0 likes · 14 min read
How to Pick the Best Java HotSpot GC: Serial, Parallel, CMS, G1 & ZGC
Python Programming Learning Circle
Python Programming Learning Circle
Mar 27, 2020 · Fundamentals

Understanding Python Memory Management: Reference Counting, Circular References, and Generational Garbage Collection

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.

Garbage CollectionGenerational GCMemory Management
0 likes · 8 min read
Understanding Python Memory Management: Reference Counting, Circular References, and Generational Garbage Collection
Java Captain
Java Captain
Mar 27, 2020 · Fundamentals

Comprehensive Overview of Java JVM Runtime Data Areas, Memory Model, Garbage Collection, and Class Loading

This article provides a detailed explanation of the Java Virtual Machine's runtime memory regions, the Java Memory Model, garbage collection mechanisms, heap layout, HotSpot VM internals, class loading process, and performance tuning parameters, offering a solid foundation for Java developers and architects.

Class LoadingGarbage CollectionJVM
0 likes · 29 min read
Comprehensive Overview of Java JVM Runtime Data Areas, Memory Model, Garbage Collection, and Class Loading
Programmer DD
Programmer DD
Mar 19, 2020 · Fundamentals

What’s New in JDK 14? 16 Game‑Changing Features You Need to Know

On March 17, JDK 14 was officially released, bringing 16 new JEPs—including pattern‑matching for instanceof, a new packaging tool, enhanced G1 memory allocation, JFR event streaming, helpful NullPointerExceptions, records, switch expressions, ZGC on macOS/Windows, and a second preview of Text Blocks—significantly expanding Java’s core capabilities.

Garbage CollectionJDK 14JEP
0 likes · 6 min read
What’s New in JDK 14? 16 Game‑Changing Features You Need to Know