BestHub
Sign in
Tagged articles

Garbage Collection

504 articles · Page 1 of 6
Java Tech Enthusiast
Java Tech Enthusiast
Aug 3, 2026 · Backend Development

JDK 27 Switches Default GC to G1—Why Your Unchanged Java Service Might Slow Down

JDK 27 changes the default garbage collector from a resource‑aware Serial GC to G1, which can unexpectedly increase CPU usage, alter latency and throughput for small‑container Java services even when no code or JVM flags are changed, so teams must verify the GC in use and benchmark both collectors under realistic limits.

G1 GCGarbage CollectionJDK 27
0 likes · 22 min read
JDK 27 Switches Default GC to G1—Why Your Unchanged Java Service Might Slow Down
Tinker Programmer
Tinker Programmer
Jul 18, 2026 · Backend Development

From CMS to ZGC: How Java GC Pauses Dropped Below 1 ms

The article chronicles Java’s garbage‑collector evolution—from the deprecated CMS to G1’s pitfalls and the low‑latency ZGC and Shenandoah—explaining why CMS was removed, how G1 can degrade, and how ZGC/Shenandoah achieve sub‑millisecond pauses, plus new JDK 25/26 features and practical tuning steps.

G1Garbage CollectionJDK25
0 likes · 18 min read
From CMS to ZGC: How Java GC Pauses Dropped Below 1 ms
Coder Trainee
Coder Trainee
Jul 13, 2026 · Fundamentals

Top 10 Must‑Ask JVM Interview Questions

This article presents ten essential JVM interview questions, covering the Java 8 memory model, object allocation flow, common GC algorithms and collectors, class‑loading mechanics, OOM and CPU‑spike troubleshooting, tuning parameters, and the differences among strong, soft, weak and phantom references.

Class LoadingGarbage CollectionJVM
0 likes · 12 min read
Top 10 Must‑Ask JVM Interview Questions
Tinker Programmer
Tinker Programmer
Jul 13, 2026 · Backend Development

Choosing the Right Java LTS for Production: Lessons from 12 Years of Java 8‑25 Evolution

The article reviews the twelve‑year evolution of Java LTS releases from 8 to 25, explains the new six‑month release cadence, details common upgrade pitfalls, quantifies performance gains such as virtual threads and ZGC, and provides concrete version‑selection guidance for legacy, mid‑life, and new projects.

Garbage CollectionJDKLTS
0 likes · 16 min read
Choosing the Right Java LTS for Production: Lessons from 12 Years of Java 8‑25 Evolution
Coder Trainee
Coder Trainee
Jun 25, 2026 · Backend Development

Java Performance Tuning Part 1: Understanding the JVM Memory Model from a GC Log

This article launches a Java performance tuning series, explaining why GC logs are the starting point, reviewing the JVM memory model, showing how to enable and read GC logs, dissecting minor and full GC entries, comparing common GC algorithms, and introducing visualization tools to help pinpoint memory issues.

GCGarbage CollectionJVM
0 likes · 10 min read
Java Performance Tuning Part 1: Understanding the JVM Memory Model from a GC Log
IoT Full-Stack Technology
IoT Full-Stack Technology
Jun 17, 2026 · Backend Development

When Java Streams Crash: A Real‑World Performance Disaster

A production outage caused by a Java Stream pipeline processing one million orders revealed massive memory overhead and CPU‑bound garbage collection, prompting a benchmark that showed a handcrafted for‑loop to be up to twenty times faster and far more memory‑efficient.

Garbage CollectionMemoryStream API
0 likes · 10 min read
When Java Streams Crash: A Real‑World Performance Disaster
Programmer1970
Programmer1970
Jun 1, 2026 · Fundamentals

Why ZGC Pauses Stay Under 1 ms: Inside Colored Pointers and Load Barriers

The article explains how ZGC achieves sub‑millisecond pause times by embedding GC state in pointer bits (colored pointers) and using JIT‑injected load barriers that fix references on first access, comparing this approach with G1 and Shenandoah and detailing ZGC 2.0 enhancements and known pitfalls.

Colored PointersConcurrent GCGarbage Collection
0 likes · 11 min read
Why ZGC Pauses Stay Under 1 ms: Inside Colored Pointers and Load Barriers
Java Architect Handbook
Java Architect Handbook
May 27, 2026 · Fundamentals

What Triggers Young GC vs. Full GC in Java? Interview Guide

The article explains that Young GC fires when the Eden space is full, while Full GC can be triggered by old‑generation shortage, metaspace exhaustion, allocation‑guarantee failure, or an explicit System.gc() call, and provides interview‑ready answers, diagnostic steps, and a comparison table.

Garbage CollectionInterviewJVM
0 likes · 14 min read
What Triggers Young GC vs. Full GC in Java? Interview Guide
DeepHub IMBA
DeepHub IMBA
May 22, 2026 · Fundamentals

Inside Python’s Automatic Memory Management: Core Mechanisms and Optimization Guide

The article breaks down Python’s memory system layer by layer, explaining stack vs. heap, reference counting, generational garbage collection, the true effect of the del statement, built‑in optimizations like integer caching, string interning and __slots__, and shows how to process a 20 GB CSV efficiently with generators.

Garbage CollectionMemory ManagementOptimization
0 likes · 12 min read
Inside Python’s Automatic Memory Management: Core Mechanisms and Optimization Guide
Java Architect Handbook
Java Architect Handbook
May 21, 2026 · Backend Development

How to Diagnose Frequent Full GC in Production Systems? (Second Interview at Taobao)

The article explains why Full GC should be minimized, defines normal versus abnormal GC frequencies, outlines the root causes of Full GC, and provides a step‑by‑step troubleshooting workflow with concrete code snippets, monitoring commands and real‑world examples for Java backend engineers.

Full GCGarbage CollectionJVM performance
0 likes · 13 min read
How to Diagnose Frequent Full GC in Production Systems? (Second Interview at Taobao)
21CTO
21CTO
May 9, 2026 · Fundamentals

Top New Features in Python 3.15: Lazy Imports, Faster JIT, Better Errors, Smarter Profiling

Python 3.15’s beta introduces lazy imports, a built‑in frozendict, a sentinel type, a low‑overhead statistical profiler, an upgraded JIT with 8‑13% speed gains, clearer error messages, type‑system tweaks, new list‑comprehension unpacking syntax, and a rollback to generational garbage collection.

Garbage CollectionPythonerror-messages
0 likes · 8 min read
Top New Features in Python 3.15: Lazy Imports, Faster JIT, Better Errors, Smarter Profiling
Sohu Tech Products
Sohu Tech Products
Apr 22, 2026 · Fundamentals

Why WasmGC Is a Game‑Changer for Flutter and Kotlin Multiplatform on the Web

WasmGC introduces native garbage‑collection support to WebAssembly, enabling Kotlin and Dart to run as true native languages on the web, dramatically shrinking bundle sizes, speeding startup, eliminating memory‑leak cycles, and improving interop, with full browser support now standard across Chrome, Firefox, and Safari.

BrowserGarbage CollectionKotlin
0 likes · 8 min read
Why WasmGC Is a Game‑Changer for Flutter and Kotlin Multiplatform on the Web
ByteDance SE Lab
ByteDance SE Lab
Apr 17, 2026 · Industry Insights

How DisCoGC Cuts Storage Costs by 20%: A Deep Dive into ByteStore’s New GC Paradigm

This article analyzes the DisCoGC algorithm introduced by ByteDance, explaining how its discard‑centric garbage collection eliminates the write‑amplification vs. space‑amplification trade‑off in log‑structured storage, details the engineering challenges of multi‑layer deployment, and presents production results showing up to 20% TCO reduction without impacting latency.

Garbage Collectioncompactioncost reduction
0 likes · 19 min read
How DisCoGC Cuts Storage Costs by 20%: A Deep Dive into ByteStore’s New GC Paradigm
Lisa Notes
Lisa Notes
Mar 31, 2026 · Fundamentals

Java Objects from Scratch: A Step‑by‑Step Guide

This tutorial walks through the fundamentals of Java objects, covering declaration, instantiation, referencing, practical code examples—including a HelloTest class and a Point/Rectangle demo—and explains Java's automatic garbage collection and manual cleanup techniques.

ConstructorsExample CodeGarbage Collection
0 likes · 10 min read
Java Objects from Scratch: A Step‑by‑Step Guide
Coder Trainee
Coder Trainee
Mar 21, 2026 · Backend Development

Demystifying JVM Tuning: Practical Principles and Parameter Guide

The article outlines JVM tuning fundamentals, categorizing common issues, presenting six optimization principles, detailing key JVM parameters, and introducing the jps command‑line tool to help developers diagnose and improve Java application performance while maintaining stability.

Garbage CollectionJVMjava
0 likes · 4 min read
Demystifying JVM Tuning: Practical Principles and Parameter Guide
Coder Trainee
Coder Trainee
Mar 21, 2026 · Fundamentals

Understanding JVM Basics for Effective Tuning

The article explains the JVM's core components, execution workflow, garbage collection fundamentals—including GC roots and Stop-The-World pauses—and introduces basic tuning tools like VisualVM and Arthas, helping readers grasp where performance optimizations should focus.

ArthasGarbage CollectionJVM
0 likes · 3 min read
Understanding JVM Basics for Effective Tuning
TonyBai
TonyBai
Mar 12, 2026 · Backend Development

Why My Go Service Slowed Down on a 128‑Core Server

A 128‑core, 256‑thread server should boost Go microservice performance, but the author explains how NUMA architecture, Go's scheduler affinity loss during GC pauses, and non‑NUMA‑aware memory allocation cause cache misses, remote memory penalties, and higher latency, preventing linear scaling.

Garbage CollectionGoHigh‑core performance
0 likes · 9 min read
Why My Go Service Slowed Down on a 128‑Core Server
Golang Shines
Golang Shines
Feb 26, 2026 · Fundamentals

Rust vs Go Memory Management: The Caretaker vs the Landlord

This article compares Rust and Go memory management by using a house‑rental analogy, detailing Go's garbage‑collector landlord model and Rust's compile‑time caretaker model, illustrating each with code snippets, pros and cons, real‑world performance anecdotes, and a practical scenario matrix.

Garbage CollectionGoMemory Management
0 likes · 7 min read
Rust vs Go Memory Management: The Caretaker vs the Landlord
Top Architect
Top Architect
Feb 18, 2026 · Fundamentals

What’s New in Java 25? 10+ Game‑Changing Features Explained

The article outlines the most impactful Java 25 enhancements—including compact object headers, generational Shenandoah GC, ahead‑of‑time compilation, JFR improvements, security updates, and the removal of 32‑bit support—explaining how each change boosts performance, safety, and observability for developers.

AOTGarbage CollectionJEP
0 likes · 5 min read
What’s New in Java 25? 10+ Game‑Changing Features Explained
LuTiao Programming
LuTiao Programming
Dec 27, 2025 · Fundamentals

What 500 Java Projects Reveal: The One Pitfall Almost Every Developer Falls Into

The article shows that most Java performance problems stem from a simple, often‑overlooked mistake—using immutable String concatenation in loops, large text building, and logging—while demonstrating how StringBuilder, proper logging placeholders, and understanding the string pool can dramatically reduce GC pressure and CPU waste.

Garbage CollectionMemory ManagementStringBuilder
0 likes · 8 min read
What 500 Java Projects Reveal: The One Pitfall Almost Every Developer Falls Into
JakartaEE China Community
JakartaEE China Community
Dec 8, 2025 · Fundamentals

Generational ZGC in JDK 21: Design, Performance, and Adoption

Generational ZGC, introduced in JDK 21, applies a weak generational hypothesis to split the heap into young and old regions, improving throughput by ~10%, reducing max pause times by 10‑20%, mitigating allocation stalls, and offering a phased adoption path via JVM flags and diagnostic tools.

Garbage CollectionGenerational ZGCJDK 21
0 likes · 9 min read
Generational ZGC in JDK 21: Design, Performance, and Adoption
php Courses
php Courses
Dec 1, 2025 · Backend Development

Why PHP Memory Grows in Long‑Running Workers and How to Fix It

In long‑running PHP processes, memory usage can steadily increase due to reference counting, circular references, unreleased resources, and default garbage‑collector settings; this article explains the underlying mechanisms, common leak sources, and provides practical debugging tips and best‑practice solutions such as explicit variable cleanup, GC tuning, process restarts, and memory‑efficient extensions.

Garbage CollectionMemory ManagementPHP
0 likes · 7 min read
Why PHP Memory Grows in Long‑Running Workers and How to Fix It
Open Source Tech Hub
Open Source Tech Hub
Nov 29, 2025 · Backend Development

Why PHP Workers Never Release Memory: The Hidden Block Allocation Pattern

When moving from PHP‑FPM to long‑running processes like RoadRunner or Laravel queue workers, memory usage climbs and never drops, a pattern caused by PHP’s Zend memory manager block allocation, reference counting, and GC behavior, which can be mitigated by redesigning code and worker strategies.

Garbage CollectionMemory ManagementPHP
0 likes · 12 min read
Why PHP Workers Never Release Memory: The Hidden Block Allocation Pattern
Tech Musings
Tech Musings
Nov 27, 2025 · Backend Development

Can Go’s GreenTeaGC Beat the Standard GC? Benchmark Results Revealed

A comprehensive benchmark compares Go's experimental GreenTeaGC (enabled via GOEXPERIMENT=greenteagc) against the standard GC using 30,000 and 50,000 long‑lived TCP connections, measuring GC pauses, heap usage, CPU load and scalability, and finds no decisive performance advantage.

Garbage CollectionGoGreenTeaGC
0 likes · 17 min read
Can Go’s GreenTeaGC Beat the Standard GC? Benchmark Results Revealed
Java Tech Enthusiast
Java Tech Enthusiast
Nov 15, 2025 · Backend Development

Why Generational Shenandoah GC in JDK 25 Is a Game‑Changer for Java Performance

JDK 25 introduces the generational Shenandoah garbage collector as a production‑ready feature, offering lower pause times, higher throughput, and better memory efficiency compared to G1 and ZGC, while remaining optional via the -XX:ShenandoahGCMode=generational flag and preserving compatibility with existing scripts.

Garbage CollectionGenerational GCJDK 25
0 likes · 8 min read
Why Generational Shenandoah GC in JDK 25 Is a Game‑Changer for Java Performance
BirdNest Tech Talk
BirdNest Tech Talk
Oct 31, 2025 · Backend Development

How Go’s New Green Tea GC Slashes CPU Overhead by Up to 40%

The article examines Go 1.25’s experimental Green Tea garbage collector, explains why the traditional mark‑sweep approach hurts modern CPUs, details the page‑oriented redesign and its AVX‑512 vector acceleration, and shows how these changes can cut GC‑related CPU usage by 10‑40%.

AVX-512Garbage CollectionGo
0 likes · 7 min read
How Go’s New Green Tea GC Slashes CPU Overhead by Up to 40%
Alipay Experience Technology
Alipay Experience Technology
Oct 22, 2025 · Mobile Development

How MYKMP Enables One-Code-Three-Platform Development for Alipay’s Mobile Apps

MYKMP is Alipay’s native cross‑platform solution built on Kotlin Multiplatform and Compose, enabling a single codebase to run on Android, iOS and HarmonyOS, with detailed architecture, engineering practices, GC optimizations, and integration guidelines presented for billion‑scale applications.

Garbage CollectionHarmonyOSKotlin Multiplatform
0 likes · 20 min read
How MYKMP Enables One-Code-Three-Platform Development for Alipay’s Mobile Apps
Top Architect
Top Architect
Oct 15, 2025 · Backend Development

How to Tune JVM for 1M Daily Logins on an 8 GB Server

This article walks through a step‑by‑step guide for configuring JVM memory, selecting the right garbage collector, and fine‑tuning parameters to reliably handle a platform receiving one million login requests per day on a service node with 8 GB RAM, covering capacity planning, GC choice, heap sizing, thread stack, object aging, and monitoring.

Garbage CollectionJVMMemory Management
0 likes · 27 min read
How to Tune JVM for 1M Daily Logins on an 8 GB Server
JakartaEE China Community
JakartaEE China Community
Oct 14, 2025 · Fundamentals

What Changed in Java 21? A Complete API Comparison for Upgrading from Java 17

This article provides a detailed comparison of Java 17 and Java 21 APIs, listing deprecated and removed features, suggested replacements, new I/O and serialization capabilities, enhanced reflection, Unicode emoji support, the preview foreign memory API, and the Generational ZGC, illustrated with real‑world code examples and usage scenarios.

API changesGarbage CollectionJava 21
0 likes · 15 min read
What Changed in Java 21? A Complete API Comparison for Upgrading from Java 17
Python Crawling & Data Mining
Python Crawling & Data Mining
Sep 30, 2025 · Fundamentals

Unlock Python’s Memory Secrets: Advanced Techniques to Boost Performance

This comprehensive guide explores Python’s memory management internals, covering allocation, reference counting, garbage collection, profiling tools, optimization strategies such as slots, generators, array usage, memory views, custom allocators, and practical case studies for big data and web applications, helping developers write faster, more memory‑efficient code.

Garbage CollectionMemory ManagementPython
0 likes · 24 min read
Unlock Python’s Memory Secrets: Advanced Techniques to Boost Performance
21CTO
21CTO
Sep 29, 2025 · Backend Development

What’s New in Go 1.25? Core Generics, Performance Boosts, and GC Revolution

The article reviews Go 1.25’s major updates—including the removal of core types for generics, Cgroup‑aware GOMAXPROCS, the experimental greentea GC, a revamped JSON package, and toolchain enhancements—while offering migration tips and highlighting future language trends.

Garbage CollectionGoGo 1.25
0 likes · 8 min read
What’s New in Go 1.25? Core Generics, Performance Boosts, and GC Revolution
IT Services Circle
IT Services Circle
Sep 21, 2025 · Backend Development

Is JDK 25’s “Lightweight” Promise Just a Shortcut Parade?

The article reviews JDK 25, the latest LTS release, critiquing its superficial syntax shortcuts while highlighting the genuinely valuable additions of Structured Concurrency and Scoped Values, and examines JVM‑level improvements such as generational Shenandoah GC, ultimately questioning whether the release truly advances Java’s future.

Garbage CollectionJDK 25LTS
0 likes · 7 min read
Is JDK 25’s “Lightweight” Promise Just a Shortcut Parade?
Full-Stack Cultivation Path
Full-Stack Cultivation Path
Sep 21, 2025 · Frontend Development

WebAssembly 3.0: The Emerging Fourth Language for Front‑End Development

The article explains how WebAssembly, now in its 3.0 release, adds a fourth language to front‑end development by offering multi‑language support, near‑native performance, and new features such as 64‑bit memory, garbage collection, and tighter JavaScript integration for compute‑intensive web applications.

Front-endGarbage CollectionMulti-language
0 likes · 6 min read
WebAssembly 3.0: The Emerging Fourth Language for Front‑End Development
21CTO
21CTO
Sep 20, 2025 · Frontend Development

What’s New in WebAssembly 3.0? Exploring the Latest Features and Their Impact

WebAssembly 3.0, now the “live” standard, introduces 64‑bit address space, multi‑memory support, garbage collection, richer reference types, tail calls, exception handling, relaxed SIMD, and deterministic defaults, enabling larger applications, better language support, and broader browser adoption across Chrome, Firefox, Safari, and Wasmtime.

64-bit memoryGarbage CollectionMulti-Memory
0 likes · 6 min read
What’s New in WebAssembly 3.0? Exploring the Latest Features and Their Impact
Tencent Technical Engineering
Tencent Technical Engineering
Sep 1, 2025 · Backend Development

Mastering Go Garbage Collection: Tips to Slash Latency and Boost Performance

This article explains Go's memory management mechanisms—including GC fundamentals, stop‑the‑world marking, tri‑color marking with write barriers, hybrid write barriers, and practical optimization techniques such as reducing heap allocations, using caches, concurrency patterns, and profiling tools—to help developers identify and eliminate performance bottlenecks.

Garbage CollectionGoMemory Management
0 likes · 20 min read
Mastering Go Garbage Collection: Tips to Slash Latency and Boost Performance
Sanyou's Java Diary
Sanyou's Java Diary
Aug 28, 2025 · Backend Development

Unlocking JDK 17: Key Features, ZGC Benefits, and Upgrade Strategies

This article explores JDK 17's major language enhancements, new APIs, and performance‑focused improvements such as ZGC, then details Meituan's security‑team migration experience, performance benchmarks, practical upgrade steps, and JVM tuning tips for a smooth transition from JDK 8 to JDK 17.

Garbage CollectionJDK 17Java performance
0 likes · 28 min read
Unlocking JDK 17: Key Features, ZGC Benefits, and Upgrade Strategies
Architect's Guide
Architect's Guide
Aug 20, 2025 · Backend Development

How to Tune JVM for 1M Daily Logins on an 8GB Server Node

This article walks through a systematic, interview‑style guide for sizing and configuring JVM heap, young generation, GC choice, and related parameters to reliably support a platform that processes one million login requests per day on an 8 GB memory node.

Garbage CollectionJVMbackend
0 likes · 24 min read
How to Tune JVM for 1M Daily Logins on an 8GB Server Node
Java Captain
Java Captain
Jul 12, 2025 · Operations

Master JVM Tuning: Practical Guide to Setting Memory and GC Parameters

This article walks through essential JVM memory and garbage‑collection settings, explaining each flag—such as -Xms, -Xmx, -XX:NewSize, and GC options—through a concrete example on an 8 GB server, and provides a complete command line configuration for optimal performance and OOM diagnostics.

Garbage CollectionJVMMemory Tuning
0 likes · 7 min read
Master JVM Tuning: Practical Guide to Setting Memory and GC Parameters
php Courses
php Courses
Jun 19, 2025 · Backend Development

Unlock Go’s High‑Performance Secrets: Scheduler, GC, and Memory Model Explained

This article delves into Go’s runtime, explaining the Goroutine scheduler’s G‑P‑M model and work‑stealing, the concurrent tri‑color garbage collector with its phases and tuning flags, the memory allocation hierarchy and escape analysis, and practical tips for high‑performance Go applications.

Garbage CollectionGoMemory Model
0 likes · 6 min read
Unlock Go’s High‑Performance Secrets: Scheduler, GC, and Memory Model Explained
Programmer1970
Programmer1970
Jun 17, 2025 · Fundamentals

Why Does Full GC Happen Frequently in the JVM? Common Scenarios and Fixes

Full GC pauses all application threads and degrades performance; this article explains frequent Full GC causes such as memory leaks, large object allocation, old‑generation and metaspace shortages, and mis‑configured JVM parameters, and provides concrete detection tools and optimization strategies for each garbage collector.

Full GCGC TuningGarbage Collection
0 likes · 8 min read
Why Does Full GC Happen Frequently in the JVM? Common Scenarios and Fixes
IT Services Circle
IT Services Circle
Jun 15, 2025 · Backend Development

How to Diagnose and Fix JVM GC Pauses in High‑Concurrency Microservices

This article walks through a real‑world production case, detailing how to systematically detect, analyze, and resolve severe JVM garbage‑collection pauses in a high‑concurrency Spring Boot microservice, covering resource analysis, JVM flag tuning, G1GC migration, JMX listeners, and GC‑log investigation.

G1GCGarbage CollectionJVM
0 likes · 16 min read
How to Diagnose and Fix JVM GC Pauses in High‑Concurrency Microservices
IT Services Circle
IT Services Circle
Jun 10, 2025 · Backend Development

Master TP-Link Backend Interview: JVM, GC, Synchronization, and Redis Cache Strategies

The article shares a personal experience of TP-Link's early campus recruitment and salary expectations, then provides a comprehensive Java backend interview guide covering class‑loader delegation, JVM memory layout, garbage‑collector types, synchronized lock mechanics, and common Redis cache pitfalls with practical solutions.

Garbage CollectionJVMRedis
0 likes · 18 min read
Master TP-Link Backend Interview: JVM, GC, Synchronization, and Redis Cache Strategies
JD Tech Talk
JD Tech Talk
Jun 6, 2025 · Backend Development

Upgrade Java Projects to JDK 21: Challenges, Solutions & Best Practices

This article outlines the motivations, challenges, and step‑by‑step solutions for migrating over 100 Java applications to JDK 21, covering dependency conflicts, module system adjustments, Maven plugin compatibility, garbage‑collector selection, and practical build and deployment practices to ensure a smooth upgrade.

Dependency ManagementGarbage CollectionJDK21
0 likes · 13 min read
Upgrade Java Projects to JDK 21: Challenges, Solutions & Best Practices
Raymond Ops
Raymond Ops
Jun 2, 2025 · Operations

Mastering Java JVM Tuning: Essential Commands, GC Strategies, and Reference Types

This guide explains how to launch Java processes from the command line, details key JVM tuning flags such as -X and -XX options, describes garbage collection algorithms, reference strengths, and stop‑the‑world pauses, providing practical examples and diagrams to help developers optimize memory usage and performance.

Garbage CollectionJVMMemory Tuning
0 likes · 14 min read
Mastering Java JVM Tuning: Essential Commands, GC Strategies, and Reference Types
Alibaba Cloud Developer
Alibaba Cloud Developer
May 15, 2025 · Operations

Eliminating GC Pauses: Achieving 99.995% Uptime in a 100k QPS Java Service

Facing frequent timeouts in a high‑throughput Java service, we traced instability to long GC pauses during massive index swaps, then systematically tuned JVM parameters, explored G1, ZGC, and custom Eden‑pre‑heating techniques, ultimately achieving near‑perfect availability without adding hardware.

Garbage CollectionJVMhigh concurrency
0 likes · 23 min read
Eliminating GC Pauses: Achieving 99.995% Uptime in a 100k QPS Java Service
Radish, Keep Going!
Radish, Keep Going!
May 4, 2025 · Fundamentals

Can Green Tea GC Revolutionize Go’s Garbage Collection Performance?

This article examines Go’s concurrent mark‑sweep garbage collector, its latency advantages and scalability limits, then evaluates the new Green Tea GC proposal, detailing its span‑based scanning, benchmark results, and where it offers measurable improvements over the existing GC.

Concurrent Mark‑SweepGarbage CollectionGo
0 likes · 7 min read
Can Green Tea GC Revolutionize Go’s Garbage Collection Performance?
Cognitive Technology Team
Cognitive Technology Team
May 4, 2025 · Backend Development

Understanding Java ThreadLocal Memory Leaks: Mechanisms, Risks, Diagnosis, and Defensive Practices

This article explains the inner workings of Java's ThreadLocal, analyzes how weak and strong references can cause memory leaks in thread pools, demonstrates typical leak scenarios with code examples, and provides diagnostic tools and defensive coding practices to prevent such leaks.

Garbage CollectionThreadLocalbest practices
0 likes · 9 min read
Understanding Java ThreadLocal Memory Leaks: Mechanisms, Risks, Diagnosis, and Defensive Practices
IT Services Circle
IT Services Circle
Apr 29, 2025 · Backend Development

Understanding JVM Garbage Collection Mechanisms for Interviews

This article humorously introduces a common interview scenario and then provides a comprehensive overview of JVM garbage collection, covering memory regions, GC roots, collector types like ParNew, G1, CMS, tuning parameters, code examples, and practical tips for diagnosing and optimizing GC behavior.

Garbage CollectionJVMjava
0 likes · 8 min read
Understanding JVM Garbage Collection Mechanisms for Interviews
Tencent Technical Engineering
Tencent Technical Engineering
Mar 24, 2025 · Fundamentals

Understanding V8 Garbage Collection: Scavenger and Mark‑and‑Sweep Algorithms

V8’s garbage collector splits memory into young and old generations, using a fast Scavenger minor‑GC that marks live objects, evacuates them via semi‑space copying, and updates pointers with write barriers, while a concurrent mark‑and‑sweep major‑GC employs three‑color marking, black allocation, sweeping and optional parallel compaction, with adaptive triggering based on heap usage.

Garbage CollectionJavaScriptMark-and-Sweep
0 likes · 30 min read
Understanding V8 Garbage Collection: Scavenger and Mark‑and‑Sweep Algorithms
Tencent Docs Tech Team
Tencent Docs Tech Team
Mar 24, 2025 · Fundamentals

How V8’s Scavenger and Mark‑Sweep Algorithms Optimize JavaScript Memory Management

This article explains V8’s generational heap layout, the Scavenger minor‑GC algorithm with its marking, evacuation and pointer‑updating steps, the parallel Scavenger enhancements, the major mark‑and‑sweep collector with optional compaction, and the various triggers that decide when each garbage‑collection phase runs.

Garbage CollectionJavaScriptMark‑Sweep
0 likes · 30 min read
How V8’s Scavenger and Mark‑Sweep Algorithms Optimize JavaScript Memory Management
JD Cloud Developers
JD Cloud Developers
Mar 20, 2025 · Frontend Development

Why Does Your Browser Crash? Uncover V8’s Memory Management Secrets

This article explains how V8’s memory management and garbage‑collection mechanisms work, outlines common memory‑leak scenarios in JavaScript, and provides practical techniques and tools for detecting and optimizing memory usage to prevent browser crashes and improve performance.

Garbage CollectionJavaScriptMemory Management
0 likes · 18 min read
Why Does Your Browser Crash? Uncover V8’s Memory Management Secrets
Tencent Cloud Developer
Tencent Cloud Developer
Mar 18, 2025 · Fundamentals

Java vs Go: Syntax, OOP, Error Handling, Concurrency, Garbage Collection and Performance Comparison

The article compares Java and Go across syntax, variable declaration, object‑oriented features, error handling, concurrency models, garbage collection, resource usage, and ecosystem maturity, concluding that Go offers simpler code, lightweight concurrency and lower overhead, while Java provides a richer library ecosystem and more mature tooling, making the choice dependent on project requirements.

Garbage CollectionGoconcurrency
0 likes · 26 min read
Java vs Go: Syntax, OOP, Error Handling, Concurrency, Garbage Collection and Performance Comparison
Top Architecture Tech Stack
Top Architecture Tech Stack
Mar 17, 2025 · Backend Development

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

This article explains how to size and configure JVM options—including heap size, young generation, GC algorithm, thread stack, and metaspace—for a backend service that processes one million login requests per day on an 8 GB machine, providing step‑by‑step calculations, practical examples, and optimization tips.

Garbage CollectionJVMMemory Management
0 likes · 24 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Service Node
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Mar 12, 2025 · Backend Development

What Are GC Roots? Understanding JVM Garbage Collection Basics

The article explains the concept of GC Roots in the JVM, detailing the four main types—stack variables, static fields, constant pool references, and JNI references—along with code examples, and describes how these roots determine object liveness during garbage collection.

GC RootsGarbage CollectionJVM
0 likes · 7 min read
What Are GC Roots? Understanding JVM Garbage Collection Basics
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Mar 11, 2025 · Backend Development

Master Java Garbage Collection: Mark‑Sweep, Copying, Compact & Generational Algorithms

This article explains the main Java garbage collection algorithms—Mark‑Sweep, Mark‑Copying, Mark‑Compact, and Generational Collection—detailing their principles, advantages, and drawbacks, helping developers choose the appropriate strategy for efficient memory management in backend applications.

AlgorithmsGarbage CollectionJVM
0 likes · 5 min read
Master Java Garbage Collection: Mark‑Sweep, Copying, Compact & Generational Algorithms
Code Mala Tang
Code Mala Tang
Mar 9, 2025 · Fundamentals

What Really Happens Inside Python When You Call a Function?

This article explains step by step how Python creates a function object, builds a call stack, handles parameters, executes the body, performs garbage collection, and manages recursion, illustrating each stage with clear code examples and diagrams.

Function CallGarbage CollectionPython
0 likes · 8 min read
What Really Happens Inside Python When You Call a Function?
Radish, Keep Going!
Radish, Keep Going!
Feb 20, 2025 · Backend Development

Why Go Replaces runtime.SetFinalizer with runtime.AddCleanup and How to Use It

This article explains that Go plans to deprecate runtime.SetFinalizer in favor of the newer runtime.AddCleanup, demonstrates how to use SetFinalizer for resource cleanup before garbage collection, highlights common pitfalls such as extended lifetimes and memory leaks, and shows real‑world examples from the standard library and go‑cache.

AddCleanupGarbage CollectionGo
0 likes · 6 min read
Why Go Replaces runtime.SetFinalizer with runtime.AddCleanup and How to Use It
Architect's Guide
Architect's Guide
Jan 30, 2025 · Backend Development

JVM Parameter Tuning for 1 Million Daily Login Requests on an 8 GB Server

This article walks through a systematic, eight‑step approach to sizing and configuring JVM memory parameters—including heap, young generation, stack, object age thresholds, and garbage‑collector selection—so that a service handling one million daily logins on an 8 GB machine can achieve stable performance and predictable GC behavior.

Garbage CollectionJVMMemory Management
0 likes · 24 min read
JVM Parameter Tuning for 1 Million Daily Login Requests on an 8 GB Server
Liangxu Linux
Liangxu Linux
Jan 16, 2025 · Fundamentals

Building a Simple malloc and Mark‑Sweep GC for the Linux Kernel

This guide walks through creating a 32‑bit Linux‑kernel memory allocator using a free‑list, implementing morecore and add_to_free_list functions, and then adding a basic mark‑and‑sweep garbage collector that scans heap, BSS, data segments and the stack to reclaim unused blocks.

C programmingGarbage CollectionLinux kernel
0 likes · 12 min read
Building a Simple malloc and Mark‑Sweep GC for the Linux Kernel
Lobster Programming
Lobster Programming
Jan 6, 2025 · Fundamentals

How Does the JVM’s Three‑Color Marking Algorithm Optimize Garbage Collection?

The article explains JVM garbage‑collection techniques, comparing simple reference‑counting and reachability analysis, then details the three‑color marking algorithm—including its phases, color semantics, step‑by‑step process, and common issues like over‑marking and under‑marking—followed by solutions used in CMS and G1 collectors.

CMSG1Garbage Collection
0 likes · 11 min read
How Does the JVM’s Three‑Color Marking Algorithm Optimize Garbage Collection?
Raymond Ops
Raymond Ops
Dec 31, 2024 · Operations

Why Go’s GC Skips Scanning Pointer‑Free Objects and How It Boosts Performance

This article explains the Go runtime’s garbage‑collector optimization that skips scanning objects without pointers, describes how the noscan flag is set during memory allocation, shows the code paths that enforce the skip, benchmarks the performance gain, and offers practical tips for applying the technique in real‑world Go programs.

Garbage CollectionGoMemory Management
0 likes · 20 min read
Why Go’s GC Skips Scanning Pointer‑Free Objects and How It Boosts Performance
JavaScript
JavaScript
Dec 31, 2024 · Frontend Development

Detect and Fix Common JavaScript Memory Leaks in Front‑End Development

This guide explains what JavaScript memory leaks are, illustrates typical front‑end leak scenarios such as forgotten timers, detached DOM references, improper closures, global variables, open WebSockets, misuse of Map/Set, and console logs, and provides practical solutions to prevent and resolve each issue.

DebuggingFrontendGarbage Collection
0 likes · 7 min read
Detect and Fix Common JavaScript Memory Leaks in Front‑End Development
Test Development Learning Exchange
Test Development Learning Exchange
Dec 29, 2024 · Fundamentals

Understanding Python's del Statement and Garbage Collection

This article explains how Python's del statement removes variable references, how the interpreter's garbage collection mechanisms reclaim memory—including reference counting and cyclic‑reference detection—and provides multiple code examples demonstrating proper resource cleanup in automated testing scenarios.

Garbage CollectionMemory Managementcode-examples
0 likes · 7 min read
Understanding Python's del Statement and Garbage Collection
Sohu Tech Products
Sohu Tech Products
Dec 25, 2024 · Mobile Development

Why BuildContext Leaks Memory in Flutter and How to Prevent It

This article explains how BuildContext and various closure patterns in Flutter can cause memory leaks, demonstrates typical leak scenarios with code examples, and provides practical strategies such as disposing listeners, nullifying references, and using WeakReference or Finalizer to ensure proper garbage collection.

AnimationControllerBuildContextDART
0 likes · 10 min read
Why BuildContext Leaks Memory in Flutter and How to Prevent It
Top Architecture Tech Stack
Top Architecture Tech Stack
Dec 23, 2024 · Backend Development

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

This article explains how to plan capacity, choose the appropriate garbage collector, allocate heap and non‑heap memory, and configure JVM flags—including Xms, Xmx, Xmn, Xss, and GC‑specific options—to reliably support a service node with 8 GB RAM handling one million login requests per day.

Garbage CollectionJVMMemory Management
0 likes · 25 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node
Lobster Programming
Lobster Programming
Dec 5, 2024 · Fundamentals

How Does Java’s JVM Load Classes and Execute Code? A Deep Dive

This article explains how Java classes are loaded into the JVM, details the class loader’s parent‑delegation mechanism, and walks through the execution flow of a sample program, covering stack frames, heap allocation, dynamic linking, method area, program counter, native method stack, and garbage collection.

Class LoadingGarbage CollectionJVM
0 likes · 9 min read
How Does Java’s JVM Load Classes and Execute Code? A Deep Dive
Top Architect
Top Architect
Nov 22, 2024 · Backend Development

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

This article walks through a systematic approach to sizing and configuring JVM parameters—including heap size, young generation, GC algorithm selection, and advanced options—for a high‑traffic login service that processes one million requests per day on a server with 8 GB of memory, while explaining the underlying performance‑analysis methodology.

Garbage CollectionJVMMemory Management
0 likes · 27 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node
Java Architecture Stack
Java Architecture Stack
Nov 18, 2024 · Fundamentals

Inside Go’s Runtime: How mcache and mheap Manage Memory

This article provides a detailed technical analysis of Go's runtime memory management, covering the initialization of the mheap structure, small‑object allocation via mcache, large‑object handling, the three‑color mark‑and‑sweep garbage collector, memory release mechanisms, and the optimization techniques that coordinate mcache and mheap for efficient concurrent execution.

Garbage CollectionGoMemory Management
0 likes · 12 min read
Inside Go’s Runtime: How mcache and mheap Manage Memory
Architect
Architect
Nov 14, 2024 · Backend Development

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

This article explains, step by step, how to estimate capacity, choose the appropriate garbage collector, size the young and old generations, configure stack memory, adjust object aging thresholds, and fine‑tune CMS or G1 settings so that a Java service handling one million daily logins can run reliably on an 8 GB node.

Garbage CollectionJVMMemory Management
0 likes · 24 min read
How to Set JVM Parameters for a Platform Handling 1 Million Daily Login Requests on an 8 GB Server
Su San Talks Tech
Su San Talks Tech
Nov 7, 2024 · Backend Development

Optimizing JVM GC for High‑Throughput E‑Commerce Order Systems

This article explains how to analyze per‑second object memory usage in a 100k TPS e‑commerce order flow, choose an appropriate garbage collector, set heap and young‑generation sizes, and apply common JVM tuning parameters to reduce Full GC pauses and improve latency and throughput.

Garbage CollectionJVMjava
0 likes · 6 min read
Optimizing JVM GC for High‑Throughput E‑Commerce Order Systems
DaTaobao Tech
DaTaobao Tech
Oct 28, 2024 · Fundamentals

Garbage Collection Algorithms and Reference Counting in QuickJS

QuickJS manages memory using reference counting for each object combined with a cycle‑collector that periodically scans roots, decrements child references, and frees objects whose counts drop to zero, while also supporting traditional reachability‑based garbage‑collection techniques such as mark‑sweep, copying, and generational collection.

AlgorithmC++Garbage Collection
0 likes · 9 min read
Garbage Collection Algorithms and Reference Counting in QuickJS
Cognitive Technology Team
Cognitive Technology Team
Oct 26, 2024 · Fundamentals

Understanding G1 Garbage Collector: Concepts, Heap Regions, Pause Prediction, Object Header, and Allocation Strategies

This article explains the core concepts of the G1 garbage collector, including its memory management duties, heap region types and sizing, pause‑time prediction model, card table and bitmap usage, object header structure, and both fast and slow object allocation strategies.

G1 GCGarbage CollectionHeap Regions
0 likes · 9 min read
Understanding G1 Garbage Collector: Concepts, Heap Regions, Pause Prediction, Object Header, and Allocation Strategies
Cognitive Technology Team
Cognitive Technology Team
Oct 23, 2024 · Fundamentals

Overview of Garbage Collection Algorithms and JVM Garbage Collectors

This article provides a comprehensive overview of garbage collection techniques, covering reference counting, reachability analysis, generational management, copy, mark‑sweep, and mark‑compact algorithms, and explains the JVM's serial, parallel, CMS, and G1 collectors along with their operational characteristics and trade‑offs.

Copy AlgorithmG1Garbage Collection
0 likes · 9 min read
Overview of Garbage Collection Algorithms and JVM Garbage Collectors
MaGe Linux Operations
MaGe Linux Operations
Oct 8, 2024 · Backend Development

Master Java JVM Tuning: Key Commands, GC Options & Reference Types

This article explains how to launch Java processes from the command line, explores JVM -X and -XX tuning parameters, details garbage‑collection algorithms, describes reference strengths, and clarifies object reachability to help developers optimize Java application performance.

Garbage CollectionJVMReference Types
0 likes · 13 min read
Master Java JVM Tuning: Key Commands, GC Options & Reference Types
BirdNest Tech Talk
BirdNest Tech Talk
Oct 4, 2024 · Fundamentals

Weak Pointers Across Go, Rust, Java, and C#: Design, Implementation, and Use Cases

This article examines the concept of weak pointers and weak references in Go, Rust, Java, and C#, comparing their implementations, explaining their memory‑management semantics, presenting concrete code examples, and discussing the upcoming Go weak‑pointer proposal and practical scenarios such as caching and event handling.

C++Garbage CollectionGo
0 likes · 14 min read
Weak Pointers Across Go, Rust, Java, and C#: Design, Implementation, and Use Cases
BirdNest Tech Talk
BirdNest Tech Talk
Oct 4, 2024 · Fundamentals

How Go’s New unique Package Enables Efficient Interning and Memory Savings

Go 1.23 introduces the unique package, which provides generic interning for comparable values, allowing canonicalization of strings and structs, reducing memory usage and speeding up equality checks; the article walks through a simple map‑based implementation, its limitations, the advanced Handle[T] design, real‑world netip usage, and future prospects.

Garbage CollectionMemory Optimizationcanonicalization
0 likes · 10 min read
How Go’s New unique Package Enables Efficient Interning and Memory Savings
Code Mala Tang
Code Mala Tang
Sep 30, 2024 · Backend Development

Mastering Node.js Memory: Optimize Heap, GC, and Prevent Leaks

This article explains how Node.js manages memory, details V8's garbage‑collection mechanisms, shows how to monitor heap usage, demonstrates techniques for increasing allocation limits, and provides practical code samples and third‑party tools for detecting and fixing memory leaks in production environments.

Garbage CollectionMemory ManagementNode.js
0 likes · 20 min read
Mastering Node.js Memory: Optimize Heap, GC, and Prevent Leaks
FunTester
FunTester
Sep 30, 2024 · Backend Development

Unlock Java Performance: Essential Profiling Techniques and Tools

This guide introduces Java performance analysis fundamentals, covering profiling tools, key metrics such as CPU, memory, thread behavior, and practical methods to detect and resolve common issues like memory leaks, GC pauses, high CPU usage, I/O bottlenecks, and inefficient collection usage.

CPU analysisGarbage CollectionThread Dump
0 likes · 13 min read
Unlock Java Performance: Essential Profiling Techniques and Tools
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 27, 2024 · Backend Development

Master JVM Tuning: Practical Steps, Tools, and Real-World Code Example

This article explains why JVM tuning is essential for performance, outlines a step‑by‑step optimization workflow—including GC monitoring, heap dumps, parameter tuning, and tool usage—provides a concrete Java code example that triggers memory pressure, and shares effective JVM flags to prevent out‑of‑memory errors.

Garbage CollectionJVMMemory Management
0 likes · 7 min read
Master JVM Tuning: Practical Steps, Tools, and Real-World Code Example
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Sep 6, 2024 · Fundamentals

Understanding Java Garbage Collection Algorithms and Their Use Cases

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

GC AlgorithmsGarbage CollectionJVM
0 likes · 19 min read
Understanding Java Garbage Collection Algorithms and Their Use Cases