After a 2018 Flutter upgrade caused a mysterious “Ghost Crash” in Xianyu’s app, engineers traced an over‑released NSMutableArray in the accessibility bridge, fixed an illegal dealloc call, added proper checks for iOS Speak Screen, and eliminated the crash through a rapid gray‑scale rollout.
This article explains the overall architecture of the JVM, details each component of its runtime data area—including program counter, stacks, heap, and method area—and discusses related concepts such as the runtime constant pool and direct memory, providing a comprehensive overview for developers.
This article continues the deep dive into Apache Spark memory management, explaining storage memory handling—including RDD persistence, caching, eviction, and disk spilling—as well as execution memory allocation for multi-tasking and shuffle operations, and detailing Spark’s internal structures such as BlockManager, StorageLevel, and Tungsten page management.
This article explains Spark's memory management architecture, covering on‑heap and off‑heap memory planning, the MemoryManager interface, static versus unified memory allocation strategies, and how dynamic borrowing improves resource utilization for Spark executors.
This article explains how Xcode’s static analysis feature can automatically identify common iOS development problems—including localization warnings, logical errors, memory leaks, dead stores, and syntax mistakes—by analyzing code without execution, and shows how to resolve each type of issue.
The article explains Go slices as three‑field descriptors pointing to an underlying array, details creation methods, shows the low‑level runtime representation and assembly for make, describes how append triggers growslice with capacity‑doubling or ~25 % growth and alignment, and clarifies sharing, nil slices, and passing semantics.
This comprehensive guide explains the JVM memory areas, the fundamentals of garbage collection, generational heap management, various GC algorithms, and practical tuning parameters for Java applications.
This article explains how Xcode’s static analysis feature can automatically identify text localization problems, logic errors, memory management concerns, dead‑store data issues, and syntax mistakes in iOS projects, and provides step‑by‑step instructions and code examples for fixing each type of warning.
This guide presents 45 practical Java performance optimization techniques—ranging from proper use of singletons and final modifiers to efficient collection handling and avoiding costly operations—helping developers write faster, more memory‑efficient code.
Matrix for iOS/macOS is an open‑source performance probing tool from the WeChat team that monitors crashes, jank, and memory issues on iOS and macOS, offering plugins for detailed stack capture and out‑of‑memory reporting, with future plans for power‑consumption tracking and cloud integration.
This article provides an in‑depth overview of why Redis is used, its drawbacks, the reasons behind its single‑threaded speed, data types and use‑cases, expiration policies, memory eviction strategies, consistency challenges with databases, and practical solutions for cache penetration, cache avalanche, and concurrent key competition.
This article explores Linux kernel memory management in depth, covering process address space layout, allocation mechanisms, OOM killer behavior, the whereabouts of allocated memory, and both manual and automatic memory reclamation techniques.
During the migration of a billion‑record Java service from physical servers to a private‑cloud Docker environment, a series of JVM GC tuning steps—including adaptive young generation sizing, larger young generation, reduced concurrent GC threads, and phantom‑reference cleanup—significantly reduced stop‑the‑world pauses and restored service performance.
This article explains Redis's memory model—including memory statistics, allocation, internal data structures like redisObject and SDS, object type encodings, and practical techniques for estimating usage, reducing fragmentation, and optimizing memory consumption—providing developers with actionable insights for high‑performance backend systems.
This article explains Java's enduring popularity by highlighting its write‑once‑run‑anywhere philosophy, built‑in multithreading, automatic memory management, scalability, cross‑platform capabilities, security features, and its strong presence in enterprise, IoT, mobile, and big‑data applications.
This article explains the evolution of JVM garbage collectors from Serial to G1, details the different collector types, describes G1's memory model and collection phases, and outlines scenarios where G1 provides low‑latency, high‑throughput garbage collection for large Java applications.
This article provides a comprehensive overview of Redis, covering its core concepts, common use cases, and detailed explanations of internal objects such as redisObject, dictEntry, SDS, and the underlying data structures for String, List, Hash, Set, and ZSet, including code snippets and performance characteristics.
The article explains Java’s sun.misc.Unsafe class, detailing how to safely obtain its singleton instance, describing its low‑level memory, CAS, thread, class, and object operations, and outlining common high‑performance use cases while warning about the significant risks of misuse.
The article recounts a Java interview where the interviewer explains the memory layout, random‑access capability, and time‑complexity differences between ArrayList (array‑based) and LinkedList (node‑based), using clear examples and code snippets to illustrate fundamental data‑structure concepts.
This article provides a comprehensive overview of Linux’s core architecture, detailing the kernel, memory management, process scheduling, file systems, VFS, device drivers, networking, shells, partitioning, mounting, and essential commands, offering readers a solid foundation for understanding and working with Linux systems.
This article provides a comprehensive guide to Linux memory management, covering memory organization, address spaces, MMU translation, allocation algorithms such as the buddy system and slab allocator, usage scenarios, common pitfalls, and practical tools for monitoring and debugging memory usage.
This article explains how Spark's memory management models and configuration parameters can be tuned to handle massive billing data efficiently, covering StaticMemoryManager vs UnifiedMemoryManager, storage and shuffle memory fractions, common OOM and file‑not‑found issues, and practical performance‑optimisation tips.
This article explains how Redis stores and encodes its five data types by using various in‑memory data structures such as SDS strings, linked lists, quicklists, hash tables, skip‑lists, intsets and zip‑lists, and it also covers object mapping, expiration policies, LRU eviction, and the RDB/AOF persistence mechanisms.
This article compares Redis and Memcached across network I/O models, supported data structures, memory management mechanisms, persistence options, consistency guarantees, and clustering approaches, highlighting the strengths and trade‑offs of each in‑memory data store.
This comprehensive guide explores Linux memory architecture, address spaces, allocation algorithms like the buddy system and slab allocator, DMA handling, user‑space allocation functions, and practical pitfalls, providing developers with essential insights to optimize performance and avoid common errors.
Python’s list type appears flexible, but its underlying CPython implementation uses a dynamic resizing strategy without a pre‑allocated memory pool, allocating memory on demand via list_resize and PyMem_RESIZE, which this article explains through code analysis, memory size measurements, and practical recommendations.
This article explores how JVM memory is allocated, why objects created in methods are not reclaimed instantly, and demonstrates through experiments how Eden space, YGC, and GC behavior affect object lifetimes and overall heap utilization.
This article explains the differences between Java heap and stack memory, their advantages and disadvantages, and demonstrates how string objects are stored and shared using code examples that illustrate memory allocation and reference behavior.
This article investigates why objects allocated in a Java method are not immediately reclaimed after the method exits, demonstrating through experiments how JVM heap regions, especially the Eden space, influence garbage collection timing, and provides practical steps to control memory and CPU usage by deliberately allocating small and large objects.
This article explains how Linux memory management differs from Windows, clarifies the output of the free command—including buffers and cache—and demonstrates the performance benefits of caching through a simple 1 GB file read experiment.
Swift performance hinges on allocation choices, ARC overhead, and method dispatch, so using stack‑allocated structs instead of heap‑allocated classes, applying final or private to force static dispatch, leveraging protocol‑oriented containers, specializing generics, and enabling whole‑module optimization together yield faster, more efficient iOS code.
This article explains the JVM memory architecture—including heap, method area, stack, native stack, and program counter—details how each region is organized, and provides common JVM command‑line options and typical configuration examples for optimizing Java applications.
This article explains Python's integer object implementation, detailing how small integers are cached in a fixed‑size pool, how larger integers are managed through a dynamic PyIntBlock structure, and why using xrange (or range in Python 3) avoids memory bloat.
Linux appears to consume most of a system’s RAM, but the free command’s output, including buffers and cache, actually reflects memory used for performance optimization; this article explains the distinction, how to interpret free’s columns, and demonstrates the impact with a 1 GB file read experiment.
This article explains Linux kernel memory management from a global perspective, covering process address space layout, memory allocation mechanisms, OOM handling, the location of allocated memory, cache behavior, tmpfs usage, and the kernel's automatic memory reclamation strategies.
This article provides a comprehensive overview of Python, covering its nature as an interpreted, interactive, object‑oriented language, key benefits, coding conventions, memory management, debugging tools, core concepts like decorators, data structures, namespaces, lambda functions, testing, and many practical programming details for newcomers.
This article explores the underlying principles of Objective-C objects, analyzing instance objects, class objects, and meta-class objects through memory allocation, data structures, and pointer relationships.
This article details Alibaba’s first production use of non‑volatile memory in the Tair MDB cache service, covering deployment, performance challenges such as write imbalance and lock overhead, the optimizations applied, and design guidelines for building NVM‑based caching systems.
This article explains how memory serves as the main storage for processes, introduces the concepts of virtual memory and paging, and describes how page tables and multi‑level paging enable efficient address translation, isolation, and sharing in modern operating systems.
This article explains how computer memory works, covering physical memory characteristics, address spaces, RAM's random access nature, virtual memory translation, paging mechanisms, page size queries, and multi‑level page tables that enable efficient and secure memory management in Linux.
The article details how Redis’s incremental rehashing can double memory usage and trigger massive key eviction and scan inconsistencies in large‑scale clusters, explains the underlying dictionary structures, demonstrates the cursor bug when tables shrink, and presents a memory‑guard and scan‑cursor patch that resolves both problems.
This article provides a comprehensive overview of Redis, covering why it is used, its performance advantages, data structures, expiration and eviction strategies, cache‑database consistency, handling cache penetration and avalanche, and approaches to concurrent key competition.
This article explains how to overcome the performance, size, memory, and compatibility challenges of deploying deep‑learning inference engines on mobile devices by jointly optimizing model compression and engine implementation, covering speed tricks, cache‑friendly coding, multithreading, sparsity, quantization, NEON intrinsics, package size reduction, memory pooling, and reliability techniques.
This article explains how PHP stores variables using the zval structure, manages memory with reference counting and copy‑on‑write, implements a garbage‑collector based on color marking, and allocates memory through a custom heap that handles small, large, and huge allocations.
This article explains Spark's executor memory architecture, covering on‑heap and off‑heap allocation, static versus unified memory managers, storage and execution memory handling, RDD persistence levels, eviction policies, and shuffle memory usage, providing practical formulas and configuration tips for optimal performance.
This article provides a comprehensive overview of the Java Virtual Machine, covering its cross‑platform nature, core components, class‑loader mechanisms, memory layout, object creation steps, various garbage‑collection algorithms and collectors, as well as common interview questions and answers.
This article explains how Java developers can leverage strong, soft, weak, and phantom references—along with SoftReference, WeakReference, and WeakHashMap—to optimize memory usage, improve cache performance, and demonstrate advanced JVM tuning skills during technical interviews.
Running Java applications inside Docker containers often leads to incorrect memory and CPU allocation because the JVM ignores container limits, but Java 10 introduces native container awareness, allowing proper heap sizing and CPU throttling through updated JVM flags and Dockerfile configurations.
This article explains Linux kernel memory management, covering process address space allocation, OOM selection criteria, memory mapping types, cache behavior, tmpfs, and both manual and automatic memory reclamation mechanisms.
The article examines Flutter’s memory architecture, compares its Image widget’s graphics‑memory usage to Android ImageView’s Java and native heap behavior across OS versions, and evaluates FlutterView integration strategies—showing reuse saves native memory and offering a pre‑render trick to reduce first‑frame latency.
This article explains Linux kernel memory management, covering process address space layout, memory allocation, OOM handling, where allocated memory resides, and both manual and automatic memory reclamation techniques, with practical examples and visual illustrations.
This article provides a comprehensive overview of essential Java fundamentals, covering ThreadLocal, the JVM memory model, garbage collection mechanisms, synchronization primitives like synchronized and ReentrantLock, volatile semantics, concurrency utilities, thread pools, class loading, and common data structures such as HashMap and ConcurrentHashMap.
This article explains how Java's `new` keyword allocates objects on the heap, how object references reside on the stack, the relationship between references and objects, the mechanics of reference assignment, garbage collection conditions, and why Java uses value‑passing for method parameters.
This article provides a comprehensive overview of the Java Virtual Machine, covering its role in Java's cross‑platform execution, internal architecture including class loaders, runtime data areas, execution engine, memory management, and generational garbage collection mechanisms.
This article explains the differences between stack and heap memory on Android devices, outlines typical memory problems such as high usage, leaks, and overflow, and demonstrates practical testing methods using the dumpsys meminfo command and the LeakCanary library with code examples.
This article examines Spark's unified memory manager in version 2.2.1, detailing on‑heap and off‑heap memory regions, the four on‑heap memory pools, dynamic execution‑storage memory sharing, task memory accounting, and provides concrete calculation examples to explain UI discrepancies and runtime memory limits.
This article explains the concept, purpose, and internal architecture of the Java Virtual Machine, compares Java and C program execution, and describes the JVM's class loader, execution engine, and garbage collection subsystems with illustrative code examples and diagrams.
This article examines common memory leak and performance problems in C/C++ applications, categorizing causes such as pointer loss, improper memory release, excessive fragmentation, infinite allocation, and container misuse, and discusses diagnostic techniques, underlying allocation mechanisms, and mitigation strategies.
This article presents a comprehensive list of Java coding guidelines—including using final classes, reusing objects, favoring local variables, avoiding unnecessary initializations, and optimizing collections—to reduce resource consumption, improve execution speed, and mitigate memory‑leak risks.
This article explains Java's four reference types, the JVM's memory layout, object lifecycle states, common garbage‑collection algorithms, collector implementations, heap segmentation, class‑loading mechanics, and includes typical interview questions to help developers master memory management in Java.
This article explains Java's garbage collection mechanisms, detailing the roles and algorithms of the young generation (copying algorithm), old generation (mark‑sweep and mark‑compact), and permanent generation, along with object promotion criteria, efficiency comparisons, and memory utilization considerations.
This article investigates whether the JVM garbage collector can reclaim singleton instances that remain unused for extended periods, presenting a test program, analyzing GC logs, and explaining the GC root mechanism that keeps static singleton references alive, concluding that HotSpot 1.6 does not collect such objects.
This article provides concise explanations of key Java concepts—including object‑oriented features, access modifiers, primitive types, autoboxing, memory areas, garbage collection, class loading, inner classes, cloning, and common interview code snippets—offering a comprehensive reference for Java developers and interview preparation.
This article explains the complete lifecycle of a Java class within the JVM, covering memory areas such as the method, heap, and stack regions, and detailing the five stages—loading, linking, initialization, usage, and unloading—along with code examples illustrating active and passive references.
Redis and Memcached are compared across network I/O models, supported data structures, memory management, persistence, consistency, and clustering, revealing Redis’s richer feature set and flexibility while highlighting Memcached’s simplicity and speed, helping developers choose the right in‑memory solution for their workloads.
This article explains how Linux manages memory by covering address translation, the buddy and slab allocation systems, the role of vmalloc and kmap, and the detailed handling of page faults, providing programmers with essential knowledge of kernel and user‑space memory operations.
This article provides a comprehensive overview of Java's garbage collection mechanism, memory regions, object access methods, allocation strategies, GC algorithms, and the various collectors used in the HotSpot JVM, helping developers understand and optimize Java memory usage.
This article explains the Java constant pool, distinguishing static and runtime pools, demonstrates string interning behavior with code examples, and shows how to inspect class files and memory settings to observe constant pool effects in the JVM.
Java's garbage collection mechanism, introduced to simplify memory management, employs various algorithms such as reference counting, tracing (mark‑and‑sweep), compacting, copying, and generational collection, each with distinct advantages, drawbacks, and implementation details, while also addressing common memory‑leak pitfalls.
The guide explains how to optimize Elasticsearch performance by managing cluster state size through shard planning, assigning dedicated master, data, ingest, and coordinating node roles, and preventing memory swapping with bootstrap.memory_lock and proper heap and OS settings.
This comprehensive guide covers Linux fundamentals, explaining GNU's role, system components, kernel subsystems, memory addressing, process management, interrupt handling, system calls, synchronization mechanisms, file systems, and device drivers, providing clear answers to common questions for learners and developers.
This article explains the JVM execution process, details the hierarchy and delegation model of class loaders, provides a custom ClassLoader implementation with example code, and describes the structure and function of the runtime data area including heap, method area, stacks, and program counter.
This tutorial demonstrates how to efficiently read large files in Java by avoiding loading all lines into memory, comparing in‑memory approaches with streaming techniques using Scanner and Apache Commons IO, and showing memory usage metrics for each method.
This article provides a comprehensive overview of Python fundamentals, covering its interpreted nature, interactivity, object‑oriented features, benefits, coding standards like PEP8, serialization with pickle, memory management, debugging tools, decorators, data structures, namespaces, lambda functions, testing, and more.
This article provides a comprehensive overview of Linux system architecture, covering the kernel, shell, file system, memory management, process scheduling, device drivers, networking, partitioning, mounting, and common command‑line tools, offering readers a solid foundation in operating‑system fundamentals.
This article explains how Java ThreadLocal works internally, details its core methods and internal classes, analyzes the relationship between Thread, ThreadLocalMap, and WeakReference, and discusses memory‑reclamation strategies and potential OOM issues when used with thread pools.
This article explains why Greenplum can encounter out‑of‑memory (OOM) errors, lists the typical causes, and provides detailed recommendations for memory‑related OS and database parameters, statement_mem settings, and the proper use of Greenplum resource queues to achieve stable and efficient cluster operation.
This article explains the origin and concept of Objective‑C Blocks, details their internal structures and memory‑management mechanisms across MRR and ARC environments, demonstrates how to use and copy Blocks, and provides guidance on avoiding retain cycles through __block and __weak modifiers.
This article shares a comprehensive set of practical tips and solutions for common Spark SQL issues—including out‑of‑memory errors, UDF‑induced GC, thread blocking, system‑property initialization, speculation side‑effects, accumulator traps, concurrent job scheduling, and excessive logging—helping engineers improve stability and efficiency of their Spark‑based financial systems.
This article explains Linux's two‑level memory model, lazy physical allocation, the glibc malloc implementation, chunk metadata, large‑vs‑small allocations, memory holes, debugging hooks, leak detection with mtrace, and practical ways to measure a process's memory usage via /proc.
This guide examines why three simple Spring Cloud microservices consume about 1.5 GB RAM, explains JVM heap and non‑heap memory structures, and provides concrete JVM option settings and container choices to dramatically reduce memory usage while maintaining functionality.
This article presents eleven essential Python interview topics, covering quote usage, argument passing, lambda functions, string formatting, memory management, string reversal techniques, list merging, class variable behavior, slice handling, mutable default arguments, and tips for writing Pythonic code, each illustrated with clear examples.
This article explains the fundamental concepts of how programs run on a computer, covering CPU, memory, I/O, system software layers, process scheduling, virtual memory, multithreading models, synchronization mechanisms, and common pitfalls that affect concurrency and performance.
This article discusses memory optimization in Android apps by addressing excessive object allocations caused by autoboxing Long values, leading to performance issues during feed scrolling. The solution involves implementing a custom data structure to reduce memory usage and improve application responsiveness.
This article explains the concepts of shallow and deep copying in Objective‑C, detailing how pointers, memory regions, and collection types behave under copy and mutableCopy, introducing three copy levels (CL1‑CL3), and highlighting common pitfalls and best practices for safe memory management.
This article explains the need for virtual memory in Linux, describes its implementation mechanisms such as swap space and lazy allocation, and details the typical layout of the kernel and user address spaces, including high‑memory handling and zone mapping.
This article explains the fundamentals of memory management, illustrating why ArrayBuffer and SharedArrayBuffer were added to JavaScript, how automatic garbage collection works, and what manual memory handling with functions like malloc and free entails, especially when using WebAssembly and C.
This guide explains Linux memory reporting with the free command, the roles of buffer and page caches, and provides step‑by‑step instructions to manually release cached memory using /proc/sys/vm/drop_caches, including practical command examples and clarifications of key concepts.
This article provides an in‑depth technical walkthrough of MySQL InnoDB's Buffer Pool, covering its core data structures, instance layout, LRU and Flush list management, memory allocation strategies, read‑ahead/write‑ahead mechanisms, double‑write buffering, and the specialized threads that keep the pool efficient.
The iOS Memory Management Seminar by Meituan provides a comprehensive overview of fundamental concepts, including manual reference counting and automatic reference counting, explains retain cycles and autorelease mechanisms, and delves into advanced memory‑management techniques to help developers write efficient, leak‑free applications.
This article explains Linux kernel memory management, covering process address space layout, memory allocation methods, OOM killer behavior, where different types of memory reside, and both manual and automatic memory reclamation techniques, illustrated with diagrams and command examples.
This article explains essential Spark concepts, illustrates common performance bottlenecks, and provides concrete tuning strategies for memory, CPU, serialization, data locality, file I/O, and shuffle reduction, backed by real‑world examples and visual metrics.
This article demystifies JavaScript memory by explaining stack and heap concepts, variable objects, primitive and reference types, and the mark‑and‑sweep garbage‑collection algorithm, helping front‑end developers write more efficient code.
This article explains the memory allocation and garbage‑collection mechanisms of Android’s Dalvik and ART runtimes, compares their algorithms, describes GC triggers, logs, and offers practical tips to reduce frame drops caused by frequent GC cycles.
This article explains Spark's executor memory architecture, covering on‑heap and off‑heap allocation, static versus unified memory managers, storage and execution memory handling, RDD persistence, eviction policies, and the role of Tungsten's page‑based management in optimizing performance.
The article examines how iOS string decoding failures caused by malformed UTF‑8 bytes can be mitigated by parsing data byte‑by‑byte and using a custom CFAllocatorRef that reuses a fixed‑size stack or pre‑allocated buffer, avoiding heap fragmentation and improving performance.
This article presents two common interview questions—one on FTP login methods and commands, and another on Python memory management mechanisms—providing detailed explanations and answers to help programmers improve their interview performance and understand underlying concepts.
This article explains where the JVM resides within the JDK, describes its four main components—ClassLoader, Native Interface, Execution Engine, and Runtime Data Areas—and details memory management, garbage‑collection algorithms, collector types, diagnostic commands, and the Java class‑file structure.
This article explores JavaScript’s primitive and reference types, detailing their immutability, assignment behavior, memory storage, comparison methods, and the role of wrapper objects, supplemented with clear code examples and diagrams to illustrate how values and objects are handled in memory.
This article explains PHP's core zval structure, how different variable types are stored, and the mechanisms of reference counting, copy‑on‑write, and garbage collection that enable efficient memory management in the Zend engine.
