BestHub
Sign in
Tagged articles
488 articles
Page 4 of 5
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.

Backend DevelopmentGarbage CollectionJVM
0 likes · 6 min read
JVM Tuning Guide: Understanding GC, Memory Model, and Configuration Options
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 CollectionJVMJava
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 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.

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

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

Garbage CollectionJVMMemory Management
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 CollectionRuntime Data Areajava8
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 CollectionJavaThreadLocal
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 CollectionJava
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.

Garbage CollectionHBaseYCSB
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 CollectionJavaOutOfMemoryError
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.

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

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

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

Garbage CollectionJavaMemory 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 CollectionJava
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.

Garbage CollectionJMMJVM
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 CollectionJavaMemory Management
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 CollectionJavaNetty
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.

DARTFlutterGarbage Collection
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 CollectionJVMJava
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.

Garbage CollectionJVMJava
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 CollectionJDK11Java
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 ManagementPerformance Monitoring
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 CollectionJVMJava
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.

GC ErgonomicsGarbage CollectionJVM
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 CollectionJVMJava
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 CollectionJVMJava
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.

Distributed TracingGarbage CollectionJava
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.

Garbage CollectionJVMMemory Management
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 CollectionJVMJava
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.

Garbage CollectionJVMJava
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
Big Data Technology Architecture
Big Data Technology Architecture
Mar 4, 2020 · Databases

HBase Memory‑Related Performance Tuning Guide

This article explains how to optimize HBase performance by properly configuring JVM memory, selecting suitable garbage‑collection strategies, enabling MSLAB and BucketCache, and adjusting read/write cache ratios to reduce fragmentation and improve throughput.

CacheGarbage CollectionHBase
0 likes · 8 min read
HBase Memory‑Related Performance Tuning Guide
macrozheng
macrozheng
Mar 3, 2020 · Fundamentals

Mastering Java Garbage Collection: Algorithms, Regions, and Tuning Tips

This article provides a comprehensive overview of Java's automatic garbage collection, covering memory regions, identification methods, core algorithms such as mark‑sweep, copying, and generational collection, detailed explanations of various collectors (Serial, CMS, G1, etc.), and practical tuning insights for optimal performance.

Garbage CollectionJVMJava
0 likes · 31 min read
Mastering Java Garbage Collection: Algorithms, Regions, and Tuning Tips
Selected Java Interview Questions
Selected Java Interview Questions
Mar 2, 2020 · Fundamentals

Understanding Java Reference Types: SoftReference, WeakReference, and PhantomReference Implementation Details

This article explains Java's four reference types, focusing on the implementation and lifecycle of SoftReference, WeakReference, and PhantomReference, and clarifies how garbage collection policies, native and Java layers, and reference queues determine when these references are cleared or notified.

Garbage CollectionJavaPhantomReference
0 likes · 14 min read
Understanding Java Reference Types: SoftReference, WeakReference, and PhantomReference Implementation Details
Architect's Tech Stack
Architect's Tech Stack
Feb 23, 2020 · Fundamentals

Top 5 New Features Expected in Java 14

This article outlines the five major preview features slated for Java 14, including instanceof pattern matching, text blocks with new escape sequences, record types, the incubating jpackage tool, and the deprecation of the ParallelScavenge + SerialOld garbage collector combination.

Garbage CollectionText Blocksjava14
0 likes · 9 min read
Top 5 New Features Expected in Java 14
Programmer DD
Programmer DD
Feb 23, 2020 · Backend Development

How to Replace the Deprecated CMS GC in JDK 9?

This article explains why the CMS garbage collector was removed in JDK 9, shows the deprecation warning, and evaluates three migration paths—switching to G1 GC, adopting ZGC, or continuing with CMS—helping developers choose the best option for their applications.

CMS GCGarbage CollectionJDK9
0 likes · 5 min read
How to Replace the Deprecated CMS GC in JDK 9?
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jan 22, 2020 · Fundamentals

Understanding the Flash‑Friendly File System (F2FS): Design, Implementation, and Future Directions

F2FS is a log‑structured, flash‑aware file system that transforms random writes into sequential ones, uses segment‑based layout, NAT indexing, and hot‑cold data segregation with sophisticated garbage‑collection to improve SSD performance, and is now deployed in Android devices with ongoing enhancements such as online resizing and cold‑data compression.

F2FSGarbage CollectionStorage Management
0 likes · 17 min read
Understanding the Flash‑Friendly File System (F2FS): Design, Implementation, and Future Directions
Architect's Tech Stack
Architect's Tech Stack
Jan 18, 2020 · Fundamentals

JVM Memory Architecture: Overview, Heap, Metaspace, Stack, and More

This article provides a comprehensive overview of the Java Virtual Machine memory layout, covering heap regions, Metaspace, stack frames, native method stack, program counter, direct memory, and code cache, along with configuration tips, diagnostic commands, and illustrative code examples to help readers understand memory allocation and garbage collection.

Garbage CollectionHeapJVM
0 likes · 16 min read
JVM Memory Architecture: Overview, Heap, Metaspace, Stack, and More
Efficient Ops
Efficient Ops
Jan 16, 2020 · Operations

Mastering WAS Memory Overflow: Elegant Strategies for Resolution

This article explains IBM WebSphere Application Server's memory architecture, common causes of Java OutOfMemoryError in WAS, and provides a step‑by‑step guide—including log collection, heap analysis, and preventive measures—to diagnose, resolve, and avoid memory overflow incidents in production environments.

Garbage CollectionOperationsWAS
0 likes · 16 min read
Mastering WAS Memory Overflow: Elegant Strategies for Resolution
Tencent Cloud Middleware
Tencent Cloud Middleware
Jan 3, 2020 · Fundamentals

Why Reference Counting Fails: Understanding GC, Memory Leaks, and Circular References

This article explains the origins of garbage collection, illustrates common memory‑management pitfalls with C‑style malloc/free examples, introduces reference‑counting fundamentals, shows how cyclic references break the algorithm, and compares programmer‑assisted versus runtime solutions while highlighting their trade‑offs.

Automatic Memory ManagementCyclic ReferencesGarbage Collection
0 likes · 16 min read
Why Reference Counting Fails: Understanding GC, Memory Leaks, and Circular References
360 Tech Engineering
360 Tech Engineering
Dec 17, 2019 · Backend Development

Diagnosing Java Memory Leaks: JVM GC Roots, Monitoring, and Code Fixes

This article explains how Java memory leaks can occur despite automatic garbage collection, describes JVM GC‑Root analysis, outlines practical monitoring with Spring Boot Actuator, Prometheus, and Grafana, and provides step‑by‑step debugging commands and code adjustments to locate and fix the leak.

Garbage CollectionJVMJava
0 likes · 10 min read
Diagnosing Java Memory Leaks: JVM GC Roots, Monitoring, and Code Fixes
Huajiao Technology
Huajiao Technology
Dec 17, 2019 · Backend Development

Diagnosing Java Memory Leaks: JVM GC Roots, Monitoring with Spring Boot Actuator, Prometheus, Grafana, and MAT

This article explains how Java memory leaks can occur despite automatic garbage collection, describes JVM reachability analysis, shows how to monitor and detect leaks using Spring Boot Actuator, Prometheus, and Grafana, and provides step‑by‑step instructions for heap dump analysis and code fixes.

Garbage CollectionGrafanaJVM
0 likes · 11 min read
Diagnosing Java Memory Leaks: JVM GC Roots, Monitoring with Spring Boot Actuator, Prometheus, Grafana, and MAT
Selected Java Interview Questions
Selected Java Interview Questions
Nov 29, 2019 · Fundamentals

Understanding Object Liveness Determination in Java: Reference Counting and Reachability Analysis

The article explains how Java determines whether an object is alive using two main garbage‑collection algorithms—Reference Counting and Reachability Analysis—detailing their mechanisms, limitations such as circular references, the role of GC Roots, finalization, and method‑area reclamation, with illustrative code examples.

Garbage CollectionJVMJava
0 likes · 6 min read
Understanding Object Liveness Determination in Java: Reference Counting and Reachability Analysis
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 27, 2019 · Backend Development

Why Does Your Java App Freeze? Uncover Full GC Causes and Fixes

Discover why Java applications suddenly freeze due to full garbage collection, explore common GC triggers and memory‑leak scenarios, and learn practical strategies—such as eliminating leaks, applying concurrency limits, adaptive rate‑limiting, and traffic monitoring—to keep your backend services stable.

BackendFull GCGarbage Collection
0 likes · 8 min read
Why Does Your Java App Freeze? Uncover Full GC Causes and Fixes
Big Data Technology Architecture
Big Data Technology Architecture
Nov 19, 2019 · Backend Development

CMS GC JVM Parameter Tuning Guide for HBase Clusters

This article explains the fundamentals of the CMS (Concurrent Mark Sweep) garbage collector, presents a comprehensive set of JVM parameters optimized for HBase clusters, and provides detailed analysis of key settings to improve performance and reduce GC pauses.

CMS GCGarbage CollectionHBase
0 likes · 7 min read
CMS GC JVM Parameter Tuning Guide for HBase Clusters