BestHub
Sign in
Tagged articles

Garbage Collection

515 articles · Page 3 of 6
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
May 29, 2023 · Backend Development

Why Is My Go Health‑Check So Slow? Diagnosing TCP Latency and GC Overhead

This article investigates why a Go‑based service health‑check system experiences high latency, examines differences from Nginx checks, runs experiments on physical machines and Docker, and explores goroutine scheduling, GOMAXPROCS, and garbage‑collection tuning to reduce average response time from 40 ms to under 10 ms.

DockerGarbage CollectionPerformance Optimization
0 likes · 10 min read
Why Is My Go Health‑Check So Slow? Diagnosing TCP Latency and GC Overhead
vivo Internet Technology
vivo Internet Technology
May 10, 2023 · Databases

Design and Optimization of a Disk‑Based KV Store Compatible with Redis on TiKV

The article details a Redis‑compatible, disk‑based KV service built atop TiKV using a compute‑storage split (Tula), describes custom key encoding and expiration mechanisms, and explains four optimization stages that introduce slot‑based hashing and adaptive concurrency to dramatically cut garbage‑collection latency while preserving write performance.

Database OptimizationGarbage CollectionKV store
0 likes · 21 min read
Design and Optimization of a Disk‑Based KV Store Compatible with Redis on TiKV
JD Cloud Developers
JD Cloud Developers
May 10, 2023 · Fundamentals

Mastering Java Garbage Collectors: When to Choose Serial, Parallel, CMS, or G1

This article explores the evolution of Java garbage collectors—from the simple Serial and Parallel collectors to the concurrent CMS and region-based G1—detailing their algorithms, tuning parameters, strengths, weaknesses, and best‑practice recommendations for selecting the optimal collector based on workload and memory constraints.

Garbage CollectionJVMJava
0 likes · 14 min read
Mastering Java Garbage Collectors: When to Choose Serial, Parallel, CMS, or G1
ByteDance Web Infra
ByteDance Web Infra
May 9, 2023 · Fundamentals

WebAssembly Runtime Architecture: Loading, Parsing, Execution, Memory Management and GC

This article provides a comprehensive overview of the WebAssembly runtime, detailing its binary format, module loading and validation, execution engine designs, linear memory layout, garbage‑collection proposals, and the WebAssembly System Interface (WASI), while illustrating each concept with diagrams and code examples.

CompilationGarbage CollectionWASI
0 likes · 34 min read
WebAssembly Runtime Architecture: Loading, Parsing, Execution, Memory Management and GC
ByteFE
ByteFE
May 8, 2023 · Fundamentals

Deep Dive into WebAssembly Runtime Architecture: Parsing, Execution, Memory Management, and WASI

This article provides a comprehensive technical analysis of the WebAssembly runtime architecture, detailing the module loading and parsing process, stack-based execution engines, linear memory management strategies, and the evolving garbage collection proposals, while also introducing the WebAssembly System Interface (WASI) for cross-platform system interactions.

Bytecode ExecutionGarbage CollectionVirtual Machine
0 likes · 32 min read
Deep Dive into WebAssembly Runtime Architecture: Parsing, Execution, Memory Management, and WASI
DeWu Technology
DeWu Technology
May 5, 2023 · Fundamentals

Understanding JVM Safepoints: Concepts, Examples, and Tuning

JVM safepoints are pause points where the VM can stop all threads for operations like garbage collection; the article shows how counted loops can prevent threads from reaching safepoints, causing unexpected long sleeps, and explains tuning flags, loop‑counter changes, and best practices to avoid STW pauses.

Garbage CollectionJVMJava
0 likes · 18 min read
Understanding JVM Safepoints: Concepts, Examples, and Tuning
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
May 4, 2023 · Fundamentals

Comprehensive Guide to JVM Memory Model, Garbage Collection Algorithms, Collectors, Performance Tuning, and Tools

This article provides a comprehensive overview of the JVM, covering its memory model, heap and stack structures, four garbage‑collection algorithms, seven collectors including G1 and ZGC, performance‑tuning steps, analysis tools, and guidance on obtaining the full series of resources.

Garbage CollectionJVMJava
0 likes · 5 min read
Comprehensive Guide to JVM Memory Model, Garbage Collection Algorithms, Collectors, Performance Tuning, and Tools
Programmer DD
Programmer DD
Apr 30, 2023 · Backend Development

Why Java 17 Adoption Soared 430% in One Year – 2023 Ecosystem Insights

The 2023 New Relic Java ecosystem report reveals that Java 17 usage jumped over 430% in a single year, Java 11 remains dominant, Amazon Corretto now leads JDK market share, containerized deployments hit 70%, and the G1 garbage collector stays the top choice among Java 11+ users.

2023 ReportGarbage CollectionJDK
0 likes · 6 min read
Why Java 17 Adoption Soared 430% in One Year – 2023 Ecosystem Insights
JD Cloud Developers
JD Cloud Developers
Apr 27, 2023 · Fundamentals

Understanding JVM Runtime Memory and Garbage Collection: A Complete Guide

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

GC algorithmsGarbage CollectionGenerational GC
0 likes · 16 min read
Understanding JVM Runtime Memory and Garbage Collection: A Complete Guide
JD Cloud Developers
JD Cloud Developers
Apr 5, 2023 · Backend Development

Avoid Common ThreadPool Pitfalls in Java: Best Practices and Gotchas

This article examines frequent mistakes when using Java thread pools—such as improper creation, unreasonable parameters, unreleased local pools, and unsafe concurrent operations—and provides detailed analysis, configuration guidelines, and best‑practice recommendations to prevent memory leaks, deadlocks, and performance issues.

ConcurrencyGarbage CollectionJava
0 likes · 17 min read
Avoid Common ThreadPool Pitfalls in Java: Best Practices and Gotchas
21CTO
21CTO
Mar 31, 2023 · Backend Development

Boost Go Performance: 6 Proven Techniques for Faster, Leaner Apps

This article presents six practical Go performance optimizations—including GOMAXPROCS tuning for Kubernetes, struct field ordering, garbage‑collection limits, zero‑copy unsafe conversions, jsoniter usage, and sync.Pool pooling—that together can dramatically lower CPU, memory, and latency in production services.

Garbage CollectionGoKubernetes
0 likes · 9 min read
Boost Go Performance: 6 Proven Techniques for Faster, Leaner Apps
Selected Java Interview Questions
Selected Java Interview Questions
Mar 29, 2023 · Backend Development

JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node

This article presents a comprehensive, step‑by‑step guide on estimating capacity, selecting and configuring garbage collectors, sizing heap, young and survivor spaces, tuning thread stacks, and adding diagnostic options for a Java service that must handle one million login requests per day on a server with 8 GB of memory.

CMSG1Garbage Collection
0 likes · 26 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node
Java Backend Technology
Java Backend Technology
Mar 24, 2023 · Backend Development

Optimizing JVM Settings for 1M Daily Logins on an 8GB Server

This article walks through a step‑by‑step approach to sizing JVM heap, young generation, GC selection, and related parameters for a platform handling one million login requests per day on a node with 8 GB memory, providing practical formulas, example configurations, and tuning tips.

Garbage CollectionJVMJava
0 likes · 24 min read
Optimizing JVM Settings for 1M Daily Logins on an 8GB Server
Architect
Architect
Mar 18, 2023 · Backend Development

How to Configure JVM Parameters for a Platform Handling 1 Million Daily Login Requests on an 8 GB Server

This article explains a step‑by‑step methodology for estimating capacity, selecting appropriate garbage collectors, sizing JVM memory regions, and tuning advanced parameters such as survivor ratio, tenuring threshold, and Metaspace to reliably support a login service that processes one million requests per day on a machine with 8 GB of RAM.

BackendGarbage CollectionJVM
0 likes · 25 min read
How to Configure JVM Parameters for a Platform Handling 1 Million Daily Login Requests on an 8 GB Server
JD Tech
JD Tech
Mar 16, 2023 · Fundamentals

A Comprehensive Overview of Java Garbage Collection Algorithms and ZGC

This article explains the fundamentals of Java garbage collection, detailing classic algorithms such as reference counting, reachability analysis, mark‑sweep, copying, mark‑compact, and generational collectors, then introduces modern collectors like Serial, Parallel, CMS, G1, and the low‑latency ZGC, highlighting their mechanisms, advantages, and drawbacks.

Garbage CollectionJVMZGC
0 likes · 27 min read
A Comprehensive Overview of Java Garbage Collection Algorithms and ZGC
Ctrip Technology
Ctrip Technology
Mar 9, 2023 · Backend Development

Optimizing Hotel Query Service Memory Usage: GC Tuning, Native Memory Management, and Migration to jemalloc

This article details the systematic reduction of memory consumption for Ctrip's hotel query service by halving container memory, evaluating and tuning modern garbage collectors, diagnosing off‑heap leaks, and ultimately replacing the default ptmalloc allocator with jemalloc to achieve stable performance and lower resource costs.

Backend PerformanceContainerizationGarbage Collection
0 likes · 22 min read
Optimizing Hotel Query Service Memory Usage: GC Tuning, Native Memory Management, and Migration to jemalloc
Top Architect
Top Architect
Mar 8, 2023 · Backend Development

JVM Parameter Tuning for a Service Handling 10 Million Daily Login Requests on an 8 GB Node

This article walks through a systematic approach to sizing and configuring JVM parameters—including heap, young generation, GC algorithm, Metaspace, and safety‑point settings—for a high‑traffic login service that receives one million requests per day on a server with 8 GB of memory, providing both practical code examples and interview‑style explanations.

BackendGarbage CollectionJVM
0 likes · 25 min read
JVM Parameter Tuning for a Service Handling 10 Million Daily Login Requests on an 8 GB Node
Selected Java Interview Questions
Selected Java Interview Questions
Mar 5, 2023 · Backend Development

JVM Parameter Tuning for a Platform with 1 Million Daily Login Requests on an 8 GB Node

This article walks through a systematic approach to sizing and configuring JVM memory and garbage‑collector parameters for a service handling one million login requests per day on an 8 GB server, covering capacity planning, GC selection, heap region sizing, thread‑stack settings, dynamic age thresholds, large‑object handling, and diagnostic options such as heap dumps and GC logging.

Garbage CollectionJVMJava
0 likes · 23 min read
JVM Parameter Tuning for a Platform with 1 Million Daily Login Requests on an 8 GB Node
vivo Internet Technology
vivo Internet Technology
Feb 22, 2023 · Backend Development

Game Recommendation System: Architecture, Models, Scaling, and Operational Practices

The article details the design, evolution, and operational practices of Vivo’s large‑scale game recommendation platform, covering its initial rule‑based model, layered strategy framework, multi‑level caching, GC tuning, rate‑limiting, fine‑grained A/B testing, multi‑path recall, dynamic exposure control, and future intelligent extensions.

A/B testingGarbage Collectionbackend architecture
0 likes · 17 min read
Game Recommendation System: Architecture, Models, Scaling, and Operational Practices
ByteDance SYS Tech
ByteDance SYS Tech
Feb 16, 2023 · Fundamentals

Unlocking G1 FullGC: Inside OpenJDK’s Garbage‑First Full Collection Mechanism

This article dives deep into the OpenJDK G1 FullGC implementation, explaining its architecture, trigger conditions, preparation steps, and the four‑phase collection process while comparing single‑threaded and multi‑threaded implementations in JDK 8 and JDK 11, and highlighting code paths that can cause long GC pauses.

FullGCG1 GCGarbage Collection
0 likes · 18 min read
Unlocking G1 FullGC: Inside OpenJDK’s Garbage‑First Full Collection Mechanism
FunTester
FunTester
Feb 15, 2023 · Operations

Monitor JVM CPU, Load, and GC Metrics Using java.lang.management

This guide explains how to use Java's java.lang.management APIs to retrieve real-time JVM CPU usage, system load averages, garbage collection details, and heap/non‑heap memory statistics, providing code snippets and practical usage scenarios for performance testing and resource allocation.

CPU usageGarbage CollectionJVM monitoring
0 likes · 7 min read
Monitor JVM CPU, Load, and GC Metrics Using java.lang.management
21CTO
21CTO
Feb 1, 2023 · Fundamentals

Inside CPython’s Garbage Collector: Ref Counting, Cycle Detection & Generational Tricks

CPython’s garbage collector combines reference counting with a cyclic collector that uses generational strategies, fat pointers, and optimized object structures to efficiently identify and reclaim unreachable objects, handling cycles, weak references, and memory layout details while minimizing overhead.

Garbage CollectionGenerational GCPython
0 likes · 21 min read
Inside CPython’s Garbage Collector: Ref Counting, Cycle Detection & Generational Tricks
Programmer DD
Programmer DD
Jan 18, 2023 · Backend Development

James Gosling Unveils Java’s Crucial Role at AWS and His Functional‑Programming Secrets

In a reClojure 2022 keynote, Java’s creator James Gosling discussed how Java underpins AWS’s core services, the massive team optimizing its garbage collection, his love for functional programming, the challenges of turning research into practice, and his confidence in Oracle’s current stewardship of the language.

AWSGarbage CollectionJames Gosling
0 likes · 4 min read
James Gosling Unveils Java’s Crucial Role at AWS and His Functional‑Programming Secrets
DeWu Technology
DeWu Technology
Jan 9, 2023 · Fundamentals

Understanding JVM Bytecode, JIT Compilation, and Garbage Collection

The article explains how the JVM executes Java bytecode, detailing bytecode structure, lambda compilation, JIT tiers and optimizations such as inlining and escape analysis, describes runtime memory areas and generational garbage collectors—including G1, ZGC, and Shenandoah—and offers key tuning flags for balancing throughput, latency, and heap size.

Garbage CollectionJITJVM
0 likes · 52 min read
Understanding JVM Bytecode, JIT Compilation, and Garbage Collection
Architect's Guide
Architect's Guide
Dec 29, 2022 · Fundamentals

Understanding Java Garbage Collection Algorithms and JVM GC Strategies

This article explains what constitutes garbage in the Java heap, compares reference‑counting and root‑reachability approaches, demonstrates a reference‑counting example, and reviews the main garbage‑collection algorithms and collectors (Serial, ParNew, Parallel Scavenge, Serial Old, Parallel Old, CMS, G1) used by modern JVMs.

G1GC algorithmsGarbage Collection
0 likes · 19 min read
Understanding Java Garbage Collection Algorithms and JVM GC Strategies
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 23, 2022 · Fundamentals

Four JVM Garbage Collection Algorithms Explained

This article introduces the four main JVM garbage collection algorithms—Mark‑Sweep, Copying, Mark‑Compact, and Generational collection—explaining their mechanisms, suitable scenarios, advantages, and drawbacks, and summarizing how they are applied to young and old generations in modern Java virtual machines.

CopyingGarbage CollectionGenerational GC
0 likes · 7 min read
Four JVM Garbage Collection Algorithms Explained
Sanyou's Java Diary
Sanyou's Java Diary
Dec 1, 2022 · Fundamentals

Mastering JVM Memory: From Heap to Metaspace and Beyond

This article provides a comprehensive overview of the Java Virtual Machine memory architecture, covering heap layout, object allocation, Metaspace, stack frames, native method stacks, program counters, direct memory, and code cache, complete with configuration tips and practical code examples.

Garbage CollectionHeapJVM
0 likes · 18 min read
Mastering JVM Memory: From Heap to Metaspace and Beyond
Tuanzi Tech Team
Tuanzi Tech Team
Oct 26, 2022 · Backend Development

Master JVM Performance: Memory Structures, Tuning Parameters, and Monitoring Tips

Explore comprehensive JVM performance optimization, covering memory architecture, key tuning flags, garbage collector selection, common OOM scenarios, and essential monitoring tools such as jstack, jstat, JConsole, and VisualVM, with practical examples and code snippets to help you diagnose and resolve memory issues.

Garbage CollectionJVMJava
0 likes · 20 min read
Master JVM Performance: Memory Structures, Tuning Parameters, and Monitoring Tips
Programmer DD
Programmer DD
Oct 21, 2022 · Backend Development

Boost Java 8 Workloads with Oracle’s Enterprise Performance Pack

Oracle’s Enterprise Performance Pack, offered free to Java SE subscribers and OCI users, brings Java 17‑level memory management and performance enhancements—including modern garbage collection, compact strings, and improved observability—to legacy Java 8 applications, delivering up to 40% better memory and CPU efficiency under heavy loads.

Garbage CollectionJDK8Java
0 likes · 4 min read
Boost Java 8 Workloads with Oracle’s Enterprise Performance Pack
Selected Java Interview Questions
Selected Java Interview Questions
Oct 6, 2022 · Backend Development

Understanding Java Inner Class Memory Leaks and How to Avoid Them

This article explains why non‑static inner classes in Java retain references to their outer class, causing memory leaks and eventual OutOfMemoryError, and demonstrates practical solutions such as avoiding references or converting the inner class to a static one, illustrated with code examples and debugging screenshots.

Garbage CollectionInner ClassMemory Leak
0 likes · 7 min read
Understanding Java Inner Class Memory Leaks and How to Avoid Them
Su San Talks Tech
Su San Talks Tech
Sep 17, 2022 · Fundamentals

Why Does Thread.sleep(0) Prevent GC? Uncovering JVM Safepoint Tricks

This article examines a puzzling 'prevent gc' comment in RocketMQ source, explains how inserting Thread.sleep(0) creates a JVM safepoint to avoid long GC pauses, explores counted vs uncounted loops, and demonstrates practical code modifications to improve performance.

Garbage CollectionJVMJava performance
0 likes · 13 min read
Why Does Thread.sleep(0) Prevent GC? Uncovering JVM Safepoint Tricks
php Courses
php Courses
Aug 7, 2022 · Backend Development

Key Features and Architecture of PHP 7 and PHP 8

This article outlines the major new features of PHP 8 and PHP 7, explains why PHP 7 outperforms PHP 5, describes the execution flow, web‑request lifecycle, underlying architecture, data structures, garbage‑collection mechanism, and the PHP‑FPM master‑worker model with optimization tips.

Garbage CollectionPHPPerformance
0 likes · 6 min read
Key Features and Architecture of PHP 7 and PHP 8
ELab Team
ELab Team
Aug 4, 2022 · Fundamentals

Understanding V8’s Memory Management and Garbage Collection Strategies

This article explains how the V8 JavaScript engine manages memory through stack and heap allocation, describes its generational garbage‑collection architecture—including New Space, Old Space, and various GC algorithms—and offers practical optimization techniques to reduce pause times and improve performance.

Garbage CollectionJavaScriptV8
0 likes · 21 min read
Understanding V8’s Memory Management and Garbage Collection Strategies
Programmer DD
Programmer DD
Jul 26, 2022 · Fundamentals

Java GC Evolution: From JDK 8 to JDK 18 and Performance Gains

Since JDK 8, HotSpot’s garbage collectors have undergone extensive refinements—introducing G1 as default, adding ZGC and Shenandoah, and optimizing Parallel GC—resulting in notable gains in throughput, reduced pause latency, and lower auxiliary memory usage, as demonstrated by SPECjbb2015 benchmarks across JDK 8 to JDK 18.

Garbage CollectionHotSpotJDK
0 likes · 21 min read
Java GC Evolution: From JDK 8 to JDK 18 and Performance Gains
Tencent Cloud Developer
Tencent Cloud Developer
Jul 12, 2022 · Fundamentals

Understanding Go's Automatic Memory Management and Garbage Collection (Based on TCMalloc)

Based on Google’s TCMalloc, Go’s automatic memory system organizes memory into pages and spans, uses per‑processor mcache and shared mcentral for size‑class allocation, and employs a concurrent tri‑color mark‑sweep garbage collector triggered by heap usage or large allocations, illustrating the full allocation‑to‑reclamation pipeline.

Garbage CollectionGoTCMalloc
0 likes · 21 min read
Understanding Go's Automatic Memory Management and Garbage Collection (Based on TCMalloc)
TAL Education Technology
TAL Education Technology
Jul 1, 2022 · Fundamentals

Why the JVM Can Run Cross‑Platform and an In‑Depth Look at Its Internal Architecture

This article explains how the Java Virtual Machine achieves write‑once‑run‑anywhere by abstracting platform differences, then details the JVM’s internal components—including the class‑loader subsystem, runtime data areas such as heap, stack, method area, and program counter—followed by code examples and analysis of object layout, pointer compression, and memory allocation strategies.

Garbage CollectionHeapJVM
0 likes · 30 min read
Why the JVM Can Run Cross‑Platform and an In‑Depth Look at Its Internal Architecture
Senior Brother's Insights
Senior Brother's Insights
Jun 26, 2022 · Backend Development

How ZGC Achieves Sub‑10 ms Pauses and Scalable Memory Management

This article explains ZGC’s evolution from an experimental feature in JDK 11 to a production‑ready collector in JDK 15, detailing its sub‑10 ms pause guarantee, memory‑mapping architecture, colored pointers, region layout, read barriers, and the multi‑phase concurrent collection process that together deliver low‑latency, high‑throughput garbage collection for Java applications.

Colored PointersConcurrent GCGarbage Collection
0 likes · 16 min read
How ZGC Achieves Sub‑10 ms Pauses and Scalable Memory Management
Top Architect
Top Architect
Jun 24, 2022 · Fundamentals

Understanding JVM Memory Layout: Heap, Metaspace, Stacks, and Program Counter

This article explains the JVM memory architecture, covering the heap (young and old generations, Eden and Survivor spaces), Metaspace, virtual machine stacks, native method stacks, and the program counter register, while also illustrating key JVM parameters and bytecode execution with examples.

Garbage CollectionHeapJVM
0 likes · 13 min read
Understanding JVM Memory Layout: Heap, Metaspace, Stacks, and Program Counter
Sanyou's Java Diary
Sanyou's Java Diary
Jun 3, 2022 · Fundamentals

Mastering JVM Garbage Collection: Interview Questions and Deep Dive

This article provides a comprehensive overview of JVM memory layout, explains major garbage‑collection algorithms and collectors, details how different memory regions cooperate, and offers practical tuning steps and tool usage for diagnosing GC issues in Java applications.

Garbage CollectionJVMJVM Tuning
0 likes · 26 min read
Mastering JVM Garbage Collection: Interview Questions and Deep Dive
Java One
Java One
May 14, 2022 · Fundamentals

Master Java Constructors, Method Overloading, and Memory Management: A Deep Dive

This article explains Java constructors, the importance of providing a no‑arg constructor, method overloading rules and type promotion, the use of the this and static keywords, memory cleanup strategies, garbage‑collector algorithms, JIT compilation, member initialization order, and enum usage with clear code examples.

Garbage CollectionMethod Overloadingconstructors
0 likes · 15 min read
Master Java Constructors, Method Overloading, and Memory Management: A Deep Dive
DaTaobao Tech
DaTaobao Tech
May 6, 2022 · Mobile Development

hyengine: A Unified Mobile Script Engine with JIT, Optimizations, and GC

hyengine is a lightweight, high‑performance mobile execution engine that unifies WebAssembly, JavaScript, Python and Lua via a compiler and VM, offering JIT compilation, register allocation, inline‑cache optimizations, a custom allocator (hymalloc) and a concurrent three‑color garbage collector (hygc), achieving substantial speed‑ups on macOS and Android.

Garbage CollectionJITJavaScript
0 likes · 34 min read
hyengine: A Unified Mobile Script Engine with JIT, Optimizations, and GC
Programmer DD
Programmer DD
Apr 28, 2022 · Backend Development

Why Java 11 Overtook Java 8 and What It Means for Your Projects

The 2022 Java ecosystem report reveals Java 11 surpassing Java 8 as the dominant runtime, highlights the modest adoption of non‑LTS releases like Java 14, shows Oracle’s market share shrinking while Amazon rises, and examines how container‑based deployments affect CPU, memory, and garbage‑collector choices.

BackendContainerizationGarbage Collection
0 likes · 7 min read
Why Java 11 Overtook Java 8 and What It Means for Your Projects
Ops Development Stories
Ops Development Stories
Apr 20, 2022 · Fundamentals

Understanding ZGC: Low‑Latency Garbage Collection in Java

ZGC (Z Garbage Collector) is a scalable, low‑latency collector introduced in JDK 11, featuring sub‑millisecond pause times, region‑based memory layout, colored pointers, NUMA awareness, and concurrent phases, with detailed explanations of its architecture, parameters, triggers, and log analysis.

Garbage CollectionJVMJava
0 likes · 17 min read
Understanding ZGC: Low‑Latency Garbage Collection in Java
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Apr 7, 2022 · Frontend Development

Understanding JavaScript Memory Management and Common Memory Leaks

This article explains JavaScript's memory lifecycle, defines memory leaks, enumerates typical leak patterns such as accidental globals, timers, closures and DOM references, and describes the underlying garbage‑collection strategies (mark‑and‑sweep and reference counting) together with practical mitigation techniques.

Garbage CollectionJavaScriptMemory Leak
0 likes · 18 min read
Understanding JavaScript Memory Management and Common Memory Leaks
Alibaba Terminal Technology
Alibaba Terminal Technology
Mar 28, 2022 · Backend Development

hyengine: Unifying Mobile Script Execution with JIT and Multi‑Language Support

This article introduces hyengine, a lightweight, high‑performance engine designed to run multiple scripting languages such as JavaScript, WebAssembly, and Python on mobile devices, detailing its architecture, JIT compilation, optimizer passes, memory allocator, garbage collector, and performance benchmarks compared to LLVM and other runtimes.

Garbage CollectionJITOptimization
0 likes · 36 min read
hyengine: Unifying Mobile Script Execution with JIT and Multi‑Language Support
Sanyou's Java Diary
Sanyou's Java Diary
Feb 15, 2022 · Fundamentals

Understanding Java Memory Areas and Object Layout: A Deep Dive

Explore the structure of Java's memory regions—including the program counter, stacks, heap, and method area—along with allocation algorithms, object layout, garbage collection roots, and common pitfalls such as memory leaks and StackOverflowError, providing a comprehensive guide for JVM developers.

Garbage CollectionJVMObject Layout
0 likes · 16 min read
Understanding Java Memory Areas and Object Layout: A Deep Dive
Sanyou's Java Diary
Sanyou's Java Diary
Feb 9, 2022 · Fundamentals

Master Java Garbage Collection: Types, Algorithms, and Tuning Tips

This article explains Java garbage collection fundamentals, covering why GC is needed, how it works, reference types, major collection algorithms, generational strategies, specific collectors like CMS and G1, and practical tuning and allocation rules for JVM memory management.

CMSG1Garbage Collection
0 likes · 17 min read
Master Java Garbage Collection: Types, Algorithms, and Tuning Tips
21CTO
21CTO
Feb 5, 2022 · Fundamentals

Can Java Threads Skip GC Pauses? Exploring G1 Region Fixation Proposal

This article explains the JEP 423 proposal to fix regions in the G1 garbage collector, allowing Java threads to avoid pauses during JNI critical sections and reducing GC latency, while discussing implementation details, potential heap exhaustion risks, and upcoming JDK release timelines.

G1 GCGarbage CollectionJEP 423
0 likes · 5 min read
Can Java Threads Skip GC Pauses? Exploring G1 Region Fixation Proposal
ByteFE
ByteFE
Jan 28, 2022 · Frontend Development

Curated Technical Articles: WebAssembly, Deno, Garbage Collection, Frontend Debugging, CSS Colors, FormData, and Advanced JavaScript

This newsletter curates a collection of technical articles covering WebAssembly's future, Deno's 2021 progress, JavaScript garbage collection fundamentals, front‑end debugging best practices, modern CSS color systems, FormData usage, and advanced JavaScript features like iterators and generators.

CSSFormDataGarbage Collection
0 likes · 5 min read
Curated Technical Articles: WebAssembly, Deno, Garbage Collection, Frontend Debugging, CSS Colors, FormData, and Advanced JavaScript
Full-Stack Trendsetter
Full-Stack Trendsetter
Jan 27, 2022 · Fundamentals

Understanding the Difference Between JavaScript Stack and Heap Memory

The article explains how JavaScript engines store variables in stack and heap memory, clarifies why const primitives are immutable while object properties can change, shows that new objects reside in heap, and discusses allocation efficiency and garbage‑collection behavior of both memory regions.

Garbage CollectionJavaScriptconst
0 likes · 5 min read
Understanding the Difference Between JavaScript Stack and Heap Memory
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jan 21, 2022 · Mobile Development

Understanding Android ART CC Collector: GC Challenges, Implementation Principles and Performance Optimization

The article thoroughly explains Android ART’s Concurrent Copying (CC) garbage collector—its terminology, correctness and progress requirements, engineering challenges, classic and Android‑specific algorithms, region‑based design with bump‑pointer allocation, performance benefits such as 32% lower heap usage and sub‑millisecond pauses, and its trade‑offs including doubled reserved heap space and migration overhead.

Android ARTCC CollectorConcurrent GC
0 likes · 14 min read
Understanding Android ART CC Collector: GC Challenges, Implementation Principles and Performance Optimization
Ops Development Stories
Ops Development Stories
Jan 20, 2022 · Fundamentals

Mastering JVM Garbage Collection: Algorithms, Collectors, and Tuning

This article explains the theory behind JVM garbage collection algorithms, details various collectors such as Serial, Parallel, CMS, and G1, compares their strengths and weaknesses, and explores advanced concepts like three‑color marking, write barriers, SATB, and memory management parameters.

CMSGC algorithmsGarbage Collection
0 likes · 19 min read
Mastering JVM Garbage Collection: Algorithms, Collectors, and Tuning
Xianyu Technology
Xianyu Technology
Jan 4, 2022 · Backend Development

Full GC Diagnosis and Tuning for Xianyu Backend Services

The article details three Xianyu backend incidents where Full GC pauses caused latency spikes or outages, analyzes root causes ranging from survivor space shortage and mis‑tuned CMS to oversized async Log4j events and massive string‑concatenation logs, and presents remediation steps such as switching to G1GC, adjusting Log4j settings, and using parameterized logging to eliminate the pauses.

BackendFull GCGarbage Collection
0 likes · 23 min read
Full GC Diagnosis and Tuning for Xianyu Backend Services
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Dec 24, 2021 · Fundamentals

Evolution of Garbage Collection in Go: From Mark‑Sweep to Hybrid Write Barriers

This article explains how Go's garbage collection has progressed from the simple stop‑the‑world mark‑and‑sweep algorithm in Go 1.3, through the tri‑color concurrent marking with insert and delete write barriers in Go 1.5, to the hybrid write‑barrier approach introduced in Go 1.8 that dramatically reduces pause times while preserving memory safety.

Garbage CollectionGoMark-and-Sweep
0 likes · 31 min read
Evolution of Garbage Collection in Go: From Mark‑Sweep to Hybrid Write Barriers
BaiPing Technology
BaiPing Technology
Dec 14, 2021 · Frontend Development

Why Vue 3 Relies on WeakMap for Reactivity and Memory‑Safe Caching

This article explains how Vue 3 uses a WeakMap as a cache to avoid duplicate proxies, why WeakMap is preferred over Map for memory‑safe reactive objects, and explores WeakMap fundamentals, its methods, garbage‑collection strategies, and practical applications such as DOM storage and private class fields.

Garbage CollectionWeakMapmemory management
0 likes · 13 min read
Why Vue 3 Relies on WeakMap for Reactivity and Memory‑Safe Caching
Java High-Performance Architecture
Java High-Performance Architecture
Dec 3, 2021 · Fundamentals

Unlocking JVM Secrets: Deep Dive into Memory, GC, Class Files, and Method Dispatch

This comprehensive guide explores the inner workings of the Java Virtual Machine, covering memory regions, garbage‑collection algorithms, class‑file structure, bytecode instructions, class loading mechanisms, and method dispatch strategies, providing clear explanations and code examples for developers seeking a deeper understanding of JVM fundamentals.

Class LoadingGarbage CollectionJVM
0 likes · 41 min read
Unlocking JVM Secrets: Deep Dive into Memory, GC, Class Files, and Method Dispatch
Python Programming Learning Circle
Python Programming Learning Circle
Dec 2, 2021 · Fundamentals

Understanding Python Garbage Collection: Reference Counting, Mark‑Sweep, and Generational GC

This article explains how Python’s automatic garbage collection works, covering reference counting, the problems of cyclic references, the mark‑and‑sweep algorithm, generational collection, default thresholds, and when and how to manually control the collector with code examples.

Garbage CollectionGenerational GCMark‑Sweep
0 likes · 7 min read
Understanding Python Garbage Collection: Reference Counting, Mark‑Sweep, and Generational GC
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Nov 26, 2021 · Fundamentals

Understanding V8 Engine Memory Allocation and Garbage Collection

This article explains how the V8 JavaScript engine allocates memory, why garbage collection is necessary, describes the memory layout of new and old generations, reviews common GC algorithms such as reference counting, mark‑sweep, mark‑compact and incremental marking, and offers practical tips for writing high‑performance JavaScript code.

Garbage CollectionJavaScriptV8
0 likes · 22 min read
Understanding V8 Engine Memory Allocation and Garbage Collection
Code Ape Tech Column
Code Ape Tech Column
Nov 25, 2021 · Backend Development

Comprehensive Guide to JVM Memory Areas, Garbage Collection, and Related Concepts

This article provides an in‑depth overview of the JVM runtime data structures, memory regions, garbage‑collection algorithms, GC roots, reference types, stop‑the‑world pauses, OopMap, safe points, stack‑overflow handling, class‑loading mechanisms, the parent‑delegation model, object stack allocation, and object layout, offering practical insights for Java developers preparing for interviews.

Garbage CollectionJVMJava
0 likes · 29 min read
Comprehensive Guide to JVM Memory Areas, Garbage Collection, and Related Concepts
Practical DevOps Architecture
Practical DevOps Architecture
Nov 23, 2021 · Fundamentals

Understanding Memory Leaks, Memory Overflow, Young GC STW, Major vs Full GC, and Direct Memory in Java

This article explains the difference between memory leaks and overflow, whether young GC triggers stop‑the‑world pauses, distinguishes major GC from full GC, and describes Java's direct memory usage, providing clear insights into Java memory management and performance considerations.

Garbage CollectionPerformancedirect-memory
0 likes · 4 min read
Understanding Memory Leaks, Memory Overflow, Young GC STW, Major vs Full GC, and Direct Memory in Java
Programmer DD
Programmer DD
Nov 19, 2021 · Fundamentals

Mastering JVM Memory and Garbage Collection: A Comprehensive Guide

This article provides an in-depth exploration of Java's JVM memory architecture, garbage collection algorithms, class file structure, class loading process, bytecode execution, and method dispatch mechanisms, offering practical code examples and visual diagrams to help developers understand and optimize JVM performance.

Class LoadingGarbage CollectionJVM
0 likes · 44 min read
Mastering JVM Memory and Garbage Collection: A Comprehensive Guide
Su San Talks Tech
Su San Talks Tech
Nov 8, 2021 · Fundamentals

Mastering JVM Memory: Layout, GC Algorithms, and Tuning Tips

This comprehensive guide explains the JVM memory layout, class‑loading and object‑creation process, the parent‑delegation model, various garbage‑collection algorithms and collectors, GC roots, triggers for YGC and Full GC, and practical tuning parameters to improve Java application performance.

Garbage CollectionJVMmemory management
0 likes · 15 min read
Mastering JVM Memory: Layout, GC Algorithms, and Tuning Tips
JavaEdge
JavaEdge
Oct 31, 2021 · Backend Development

Master JVM Memory & GC: 20 Essential Interview Questions Explained

This article provides a comprehensive, interview‑focused guide to the Java Virtual Machine, covering memory regions, garbage‑collection algorithms, reference types, GC roots, STW pauses, OopMap, safe points, stack overflow, class loading, the parent‑delegation model, stack allocation, and object layout, all with clear explanations and diagrams.

Garbage CollectionJVMJava
0 likes · 31 min read
Master JVM Memory & GC: 20 Essential Interview Questions Explained
vivo Internet Technology
vivo Internet Technology
Oct 27, 2021 · Backend Development

JVM Garbage Collection Tuning for a Video Service to Reduce P99 Latency

By replacing the default Parallel GC with a ParNew‑CMS collector, enlarging the Young generation, fixing Metaspace settings, and tuning CMS occupancy thresholds, the video service cut Young and Full GC pauses dramatically, lowered Full GC count by over 80%, and achieved more than 30% P99 latency reduction, with some APIs improving up to 80%.

CMSGarbage CollectionJVM
0 likes · 16 min read
JVM Garbage Collection Tuning for a Video Service to Reduce P99 Latency
Coolpad Technology Team
Coolpad Technology Team
Oct 26, 2021 · Mobile Development

Understanding ART Garbage Collection in Android: Fundamentals, Mechanisms, and Performance Optimizations

This article introduces the fundamentals of Android Runtime (ART) garbage collection, covering its historical background, key milestones, core features such as RegionTLAB, read barriers, pause behavior, generational support, target heap size calculations, multiplier impact, GC trigger thresholds, Systrace analysis, and parameter tuning strategies.

ARTAndroidGarbage Collection
0 likes · 23 min read
Understanding ART Garbage Collection in Android: Fundamentals, Mechanisms, and Performance Optimizations
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 algorithmsGarbage CollectionJVM
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 LoadingGarbage CollectionJVM
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.

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

Garbage CollectionJDK 17JDK 18
0 likes · 6 min read
Why Java 17 Is the Fastest Yet and What to Expect from Java 18