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.
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.
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.
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.
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.
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.
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.
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.
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.
The article explains why JVMs use generational garbage collection, how cross‑generation references cause missed objects during Minor GC, and how the card table together with write barriers and conditional marking dramatically reduces pause times and improves overall GC performance.
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.
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.
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.
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.
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.
This article explains JEP 519’s Compact Object Headers in Java 25, detailing how reducing the object header from up to 128 bits to 64 bits cuts memory overhead, improves cache locality, lowers garbage‑collection pressure, and delivers measurable performance gains for JVM workloads.
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.
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.
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.
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.
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.
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.
The article explains how intermittent 503 errors in a Java service are caused by long‑lasting Full GC pauses, walks through log analysis, shows how to use jstat, jcmd and MAT to pinpoint the problem, and provides a complete set of JVM tuning flags to eliminate the issue.
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%.
The article examines JDK 21's Generational ZGC, explaining its weak generational hypothesis, heap partitioning, performance gains such as a 10% throughput increase and reduced pause times, mitigation of allocation stalls, migration steps, and diagnostic tools for developers.
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.
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.
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.
This article provides a comprehensive technical guide covering Java bytecode structure, the seven-stage class lifecycle, JIT compilation, memory layout, garbage‑collection algorithms, execution engine details, and both static and dynamic bytecode enhancement techniques such as ASM, Javassist, and Java agents.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
This article explains the main conditions that cause Java objects to be promoted from the young generation to the old generation, covering age thresholds, space guarantees, dynamic age determination, and large‑object allocation rules in HotSpot JVM.
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.
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.
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.
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.
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.
This article explains why finalize() was deprecated, introduces the Java Cleaner API, compares it with reference types and try‑with‑resources, provides practical code examples, and offers guidelines to use Cleaner effectively while avoiding common pitfalls.
This article outlines essential PHP 8+ language features, explains the PHP garbage collector mechanism, compares alternative Nginx+PHP‑FPM stacks, highlights common Opcache configuration pitfalls, and provides a step‑by‑step guide to creating and publishing a Composer package.
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.
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.
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.
This article explains how the V8 JavaScript engine manages memory—including allocation, lifecycle, garbage‑collection strategies, common leak patterns, and practical optimization techniques—so developers can prevent browser crashes and improve performance.
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.
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.
This article explores V8's memory management mechanisms, explaining how browser crashes often stem from memory issues and providing insights into garbage collection, memory leaks, and optimization techniques.
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.
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.
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.
This article explains Java's two primary garbage‑collection techniques—reference counting and reachability analysis—detailing their principles, drawbacks such as circular reference issues, and why modern JVMs favor reachability analysis to safely reclaim memory.
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.
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.
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.
The CMS (Concurrent Mark Sweep) garbage collector, designed for low‑latency old‑generation reclamation, suffers from memory fragmentation, floating garbage, high CPU usage, concurrent‑mode failures, Full GC risks, and complex tuning, making it unsuitable for many production Java workloads.
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.
This article explains the Concurrent Mark Sweep (CMS) garbage collector, detailing its five phases—Initial Mark, Concurrent Mark, Remark, Concurrent Sweep, and Concurrent Reset—while highlighting how each step works to minimize pause times during old‑generation memory reclamation in Java.
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.
This article details a Java GC optimization performed on a nightly batch service, describing the original high GC and CPU load issues, the JVM parameter adjustments, memory re‑allocation, and the resulting significant reductions in GC frequency, CPU usage, and request latency.
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.
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.
This article explains how Java HotSpot uses a card‑table memory set to efficiently detect and handle cross‑generational references during young‑generation GCRoot scans, avoiding full old‑generation scans and significantly improving garbage‑collection 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.
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.
This article explains how Java's garbage collectors work, covering generational memory spaces, major algorithms such as mark‑sweep, mark‑compact, and copy, the most common collectors for young and old generations, safe points, throughput calculations, and tuning parameters.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
This article explains the internal mechanisms of JVM garbage collection, covering oopMap, safepoints, saferegions, three‑color marking, memory sets, write barriers, and the design of low‑latency collectors such as Shenandoah and ZGC, and provides practical tuning advice.
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.
This article explains the motivations for upgrading to JDK21, introduces Generational ZGC, details integration steps and monitoring setup, presents performance test results comparing ZGC and Generational ZGC, and outlines future plans for Java services at Zhaozhuan.
This article explains why the backend services were upgraded from JDK 8 to JDK 21, introduces the generational ZGC garbage collector, details its architecture, tuning parameters, integration steps, monitoring setup, and presents performance test results that demonstrate reduced allocation stalls, lower latency, higher throughput, and near‑zero GC pauses.
This article explains the JVM memory architecture—including heap, stack, native stack, method area, and program counter—detailing heap generations, object allocation strategies, object layout, reference types, and the complete lifecycle of Java objects from creation to garbage collection.
This article demonstrates how to analyze and optimize Go's garbage collection using go trace, comparing single‑threaded and concurrent implementations, and shows how tuning GOGC and GOMEMLIMIT can dramatically improve runtime and memory usage, with detailed code samples and performance metrics.
This article explains the JVM memory architecture, object lifecycle, young and old generation garbage‑collection mechanisms, tuning goals such as low latency, high throughput and large heap, and provides practical advice on monitoring, common memory‑related problems, and choosing appropriate collectors for different application scenarios.
This comprehensive guide explains the fundamentals of HotSpot CMS garbage collection, identifies nine typical GC problem scenarios, analyzes their root causes, and provides practical tuning strategies, code examples, and diagnostic tools to help Java engineers optimize performance and avoid costly pauses.
This article examines why Go's garbage collector can become a CPU bottleneck with large heaps, demonstrates the performance impact with benchmark programs, and presents practical strategies—such as using pointer‑free allocations, mmap‑backed memory, and string interning—to dramatically reduce GC pause times.
This article explains the various forms of Java OutOfMemoryError, their underlying causes such as heap exhaustion, GC overhead, metaspace limits, and native allocation failures, and provides practical solutions and code snippets to diagnose and resolve each scenario.
This article explains Go's memory management by detailing stack and heap differences, describing classic and modern garbage‑collection algorithms, tracing the evolution of Go's GC from version 1.3 to 1.8, and outlining a complete GC cycle with practical code examples.
