1 views collected around this technical thread.
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.
JVM’s generational garbage collection divides the heap into young and old generations, using two Survivor spaces to incrementally age objects, apply a copying algorithm, reduce fragmentation, improve memory utilization, and accelerate short‑lived object reclamation, ultimately enhancing overall GC performance.
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.
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 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 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.
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 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.
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.
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.