0 views collected around this technical thread.
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.
The article surveys seven common garbage‑collection algorithms—Mark‑Sweep, Reference Counting, Copying, Mark‑Compact, Conservative, Generational, and Incremental/Tri‑color—explaining their principles, strengths, weaknesses, evaluation criteria such as throughput and pause time, and practical optimizations, emphasizing that the best choice depends on specific application needs.
This article details a real‑world Netty long‑connection memory‑leak case, explains how to reproduce the problem, uses Netty's advanced leak detection to pinpoint the faulty ByteBuf usage, and presents three practical remediation strategies to permanently fix the leak.
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.
The article explains how CPython implements integers as variable‑length base‑2³⁰ arrays, pre‑allocates the small‑integer range –5 to 256 as singleton objects for performance, and demonstrates the effect of this caching using the id() function and reference‑count analysis.
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.
The article presents a high‑efficiency Android bitmap‑reuse strategy that combines the inBitmap API with atomic reference counting and a three‑layer LRU cache (active, LruCache, InBitmapPool), dramatically lowering garbage‑collection pauses and achieving over 80 % reuse on pre‑Android 8 devices.
This article explains how Java determines which objects are eligible for garbage collection using reference counting and reachability analysis, describes the main garbage‑collection algorithms such as mark‑sweep, mark‑compact, and mark‑copy, and outlines the generational GC process including MinorGC and survivor spaces.
This article explains Python's memory management, covering object references, identity via id(), reference counting, caching of small objects, the use of the is operator, handling of reference cycles with objgraph, manual reference deletion, and the generational garbage collection mechanism including thresholds and cycle detection.
This article explains Python's garbage collection mechanism, covering object management, reference counting, cyclic reference handling, the mark‑and‑sweep algorithm, and generational collection thresholds, with illustrative code examples and detailed explanations of each step.
This article explains PHP's garbage collection mechanism, detailing how reference counting works, the role of zval structures, the identification and reclamation process, and provides source code insights to compare PHP's approach with Java's garbage collection.
This article explains Java garbage collection by outlining its purpose, the criteria for reclaimable objects through reference counting and reachability analysis, when collection occurs, and the main GC algorithms—including mark‑sweep, copying, mark‑compact, and generational collection—along with common JVM collectors.
This article explains how Python stores every value as an object in memory, how reference counting works to track object usage, and how the garbage collector frees objects when their reference count drops to zero, illustrated with interactive code examples.
Python abstracts memory management through reference counting, handles cyclic references with a generational garbage collector, and employs the weak generational hypothesis to efficiently reclaim objects, as illustrated by code examples demonstrating object creation, deletion, and the behavior of different GC generations.
The article explains how Java determines whether an object is alive using two main garbage‑collection algorithms—Reference Counting and Reachability Analysis—detailing their mechanisms, limitations such as circular references, the role of GC Roots, finalization, and method‑area reclamation, with illustrative code examples.
This article explains the JVM memory model, how the JVM decides whether an object is alive using reference counting and reachability analysis, and describes the main garbage‑collection algorithms—including mark‑sweep, mark‑compact, copying, and generational collection—along with their advantages and drawbacks.
This article explains how to propagate request‑level context in a Node.js HTTP service by building a call‑tree with async_hooks, avoiding monkey‑patching, handling lifecycle quirks, preventing memory leaks, and using reference‑counted cleanup to ensure reliable context queries.
This article explains Python's garbage collection mechanisms, demonstrates how reference counting works, shows how to detect and fix memory leaks using the gc module, and illustrates the issue with urllib2 through code examples and visual diagrams.
This article describes how Baidu's QA team identified and resolved a memory‑leak issue in the Bigpipe Broker backend by analyzing a live process with pmap and GDB, extracting reference‑count problems, and fixing the atomic_add misuse that caused the leak.
This article presents a step‑by‑step case study of locating and fixing a memory‑leak problem in Baidu's Bigpipe Broker backend by analyzing a running leaking process with GDB, pmap, and custom scripts, highlighting the pitfalls of Valgrind and the importance of clear function naming.