This article explains the Java heap structure, generational layouts in JDK 1.7 and 1.8, the G1 collector's region-based approach, and detailed object allocation rules including Eden placement, large object handling, promotion thresholds, and space allocation guarantees.
The article compares Java’s mature, generational garbage collector—using mark‑copy for young objects, mark‑sweep/compact for old, with sophisticated write barriers and fragmentation handling—to Go’s non‑generational, concurrent tri‑color mark‑sweep collector that relies on a span‑based memory pool, TCMalloc optimizations, and simpler root selection.
The article shares the author’s experience reading the third edition of "Understanding the JVM," focusing on JVM memory management, garbage‑collection algorithms, tuning strategies, and practical tools, while providing concise summaries of each book section and actionable advice for Java performance optimization.
The article details Go’s runtime memory architecture—including pages, spans, mcache, and size classes—and explains its non‑generational concurrent tri‑color mark‑and‑sweep garbage collector, the required write‑barrier techniques, and the collector’s evolution, phases, trigger mechanisms, and practical code examples across Go 1.0‑1.16.
Linux swap extends virtual memory by moving infrequently used pages to disk, and this guide explains what swap is, its pros and cons, sizing recommendations for various RAM amounts, how to create and manage swap partitions or files, and performance tuning tips including swappiness and I/O optimization.
This article introduces the various Redis eviction strategies—including volatile-ttl, volatile-random, volatile-lru, volatile-lfu, allkeys-random, allkeys-lru, and allkeys-lfu—explains their behavior, shows where they are configured in redis.conf and the initServer source code, and notes the default noeviction policy when memory exceeds maxmemory.
The article explains Java’s automatic memory management, detailing JVM memory regions, object liveness via reachability analysis, allocation strategies, and the main garbage‑collection algorithms—Mark‑Sweep, Mark‑Copy, Mark‑Compact—and compares HotSpot collectors such as Serial, Parallel, CMS and G1, guiding developers to choose the best fit for their workloads.
This article explains the fundamentals of Linux virtual memory, covering its origin, paging and page tables, memory addressing, the role of swap, common questions about 32‑bit vs 64‑bit systems, and practical commands for monitoring and configuring virtual memory on Linux.
This article explains how Redis handles memory exhaustion by setting key expirations with commands like expire and pexpire, describes its lazy and periodic expiration strategies, details the eight configurable eviction policies, and dives into the internal LRU and LFU algorithms used for key eviction.
This article explains the difference between assignment, shallow copy, and deep copy in Python, shows code examples, visual diagrams, and discusses why shallow copy is the default due to its speed, memory efficiency, and typical use cases.
This article explains Redis's Simple Dynamic String (SDS) data structure, its internal layout, how it differs from traditional C strings, and the performance, memory‑reallocation, and data‑format benefits it brings to Redis's key‑value storage.
This article explains the Redis Simple Dynamic String (SDS) data structure, comparing it with traditional C strings, detailing its struct layout, O(1) length retrieval, pre‑allocation strategy, lazy space release, and provides code examples illustrating how SDS avoids buffer overflows and improves performance.
This article details how Liulishuo implemented 3D character customization in its PIE English practice app using Cocos Creator 3.0, covering native SDK integration, JSB-based cross-platform method calls, and Asset Bundle-based resource management for performance optimization.
This article explains the G1 garbage collector’s architecture, region types, pause‑time prediction model, memory allocation parameters, collection phases, and tuning considerations, providing code examples and practical insights to improve performance for Java developers.
This article explains the internal PHP7+ data structures such as _zval_struct, zend_value, and zend_string, detailing their fields, type definitions, memory layout, flexible array usage, and the associated allocation and release macros that enable efficient, binary‑safe string handling in the Zend Engine.
This article explores the role of multi‑level caching—from distributed and local caches to direct memory and CPU cache—detailing performance gains, cache‑miss handling, consistency challenges, false sharing issues, and practical mitigation techniques such as approximate LRU, random TTL, delayed double‑delete, padding, and lock‑free designs.
This article explains the four core parts of a Linux system—kernel, shell, filesystem and applications—covering memory and process management, VFS architecture, file types, directory hierarchy, partitioning, mounting, links and essential command‑line tools.
This article shares practical techniques for improving Cocos Creator game performance by reducing black‑screen time, minimizing CPU draw‑calls, and managing memory through resource compression, atlasing, cache modes, node pooling, and texture compression, all illustrated with step‑by‑step examples and screenshots.
This article explains the JVM heap memory area, its default and configurable sizes, the generational layout (Eden, Survivor, Old), how objects are allocated and promoted, and the various garbage‑collection mechanisms and JVM parameters that affect performance and memory usage.
The article explains how MySQL uses different memory areas such as Thread Memory, Sharing, and InnoDB Buffer Pool, describes the impact of large user tables on query performance, and shows that when a table size exceeds the InnoDB buffer pool capacity, sharding becomes necessary.
This article explores how introducing various cache layers—from database and distributed caches to local and CPU caches—bridges the gap between fast CPUs and slow I/O, detailing performance benefits, cache miss handling, consistency strategies, memory management, and techniques to avoid false sharing.
The article walks through Linux’s mmap file‑read workflow—from the kernel entry point and VMA creation, through page‑fault handling that allocates pages and invokes synchronous or asynchronous readahead, to munmap’s unmapping steps and the deferred file‑cache reclamation mechanisms.
After a massive crash caused by a malformed Facebook SDK payload highlighted the lack of fault‑tolerance, this article explains why iOS crash protection is essential, outlines a four‑step handling workflow, and details two main techniques—Aspect‑Oriented Programming hooks and managed zombie objects—along with their pitfalls, performance impact, and memory‑threshold formulas for safe production deployment.
This article explores the fundamentals and advanced techniques of cache optimization, covering multi‑level caching, read/write performance gains, cache miss handling, consistency strategies, heap versus direct memory, CPU cache effects, false sharing, and practical mitigation patterns.
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 provides an overview of the most common Java JVM garbage collectors—including Serial, ParNew, Parallel, Serial Old, CMS, Parallel Old, and G1—detailing their characteristics, advantages, disadvantages, typical usage scenarios, and JVM tuning parameters for optimal performance.
This article introduces Intel® Optane™ Persistent Memory (PMem), explains its performance characteristics, usage modes, the SNIA NVM programming model, and details the PMDK libraries and related tools that enable developers to build high‑performance, fault‑tolerant applications on persistent memory.
This article explains how Linux manages physical address space using SMP and NUMA architectures, describes the node, zone, and page data structures, details page allocation via the buddy system and slab allocator, and outlines user‑ and kernel‑mode page‑fault handling, swapping, and address translation mechanisms.
This article explains Linux virtual memory fundamentals, covering its purpose, paging and page tables, address translation, swap usage, common issues like 32‑bit vs 64‑bit limits, and practical commands such as free, vmstat, pmap, and sysctl for monitoring and configuring memory management.
This article uses vivid analogies to explain the concepts of physical memory, virtual memory, and Linux's paging mechanism, showing how operating systems abstract hardware resources to simplify programming while managing limited RAM through disk-backed storage.
This comprehensive guide walks through Linux memory management, explaining CPU memory access, virtual‑to‑physical address translation, page‑table initialization, zone organization, the buddy allocator, slab allocator, vmalloc, page‑fault handling, and CMA, providing code examples and diagrams to form a complete understanding.
This article explains how Linux manages virtual memory by describing the organization of virtual and physical address spaces, the mechanisms of segmentation and paging, multi‑level page tables, and the layout of user‑mode and kernel‑mode memory, including relevant kernel code examples.
This article explains why Java strings are immutable, how the JVM uses the string constant pool and the final keyword to manage memory, and demonstrates the behavior with code examples that show reference handling, object creation, and common string operations.
This article explains how Flink on YARN allocates TaskManager memory, breaks down the JVM heap, network buffers, and Flink Managed Memory, and shows how to calculate each component using configuration parameters and source‑code analysis.
This article uses a real‑world recommendation system case to explain how Java objects are created in the young generation, survive multiple young GCs, and are promoted to the old generation under various conditions such as repeated GC cycles, dynamic age thresholds, and space‑guarantee mechanisms.
This article explains how MySQL processes a GROUP BY query on a user view table, detailing the creation and use of memory and disk temporary tables, the MEM_ROOT allocation mechanism, the execution stages revealed by EXPLAIN, and how adding a composite index can eliminate temporary tables and filesort for better performance.
This guide provides a comprehensive, step‑by‑step walkthrough of the Linux performance monitoring tools top, free, and vmstat, covering command syntax, useful options, real‑world examples, output interpretation, and practical tips for effective system tuning and troubleshooting.
Understanding JVM garbage collection with the CMS collector involves grasping class‑loader hierarchies, memory regions such as Young, Old and Metaspace, the multithreaded ParNew young collector, CMS’s four‑phase mark‑sweep‑compact cycle, and applying tuning parameters—like survivor ratios, tenuring thresholds, and concurrent marking options—to minimize stop‑the‑world pauses and full GCs on typical 4‑core, 8 GB servers.
This article explains common causes of Redis latency spikes—including slow commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network saturation—and provides step‑by‑step diagnostic commands and practical mitigation techniques.
This guide outlines Redis's fundamental limitations, common performance issues such as big keys, slow queries, and connection‑pool exhaustion, and provides practical recommendations on architecture, configuration, and operational diagnostics to help developers avoid hitting Redis's boundaries.
This article provides a comprehensive overview of the Java Virtual Machine's memory layout, detailing the runtime data area—including the program counter, JVM stack, native method stack, heap, and metaspace—while explaining their structures, functions, common errors, and the role of JIT and escape analysis.
This article explains CPython’s three‑layer memory allocator, PyMalloc, detailing how it organizes blocks, pools, and arenas to efficiently serve thousands of tiny object allocations while minimizing fragmentation and falling back to the system malloc for larger requests.
This article explains the misconception that null‑assigning unused objects always improves Java garbage collection, demonstrates with concrete JVM examples how stack references affect object reachability, and shows how explicit null or variable reuse can free memory more effectively.
This article explores the purpose and inner workings of Java's String.intern method, detailing how it interacts with the string constant pool across JDK versions, illustrating memory layout differences, code examples, and practical guidelines for when to apply intern for performance gains.
Understanding the actual memory footprint of Java objects—including headers, class pointers, fields, and alignment—reveals hidden waste, and the article provides calculations for Integer objects, arrays, and collections, plus practical guidelines to reduce memory usage by preferring primitive types, smaller fields, and arrays over collections.
The article explains that when a Java thread encounters a heap OutOfMemoryError, the thread terminates but its allocated heap memory is reclaimed, allowing the remaining threads in the same process to continue operating, and demonstrates this with a multithreaded example.
This guide outlines essential Python best‑practice techniques—including memory management, choosing Python 2 vs 3, adhering to style guides, using static analysis tools, optimizing performance, profiling, testing, and continuous integration—to help developers write clean, fast, and reliable code.
This article explains how Redis, originally a single‑threaded in‑memory cache, introduced Lazy Free in version 4.0 and multi‑threaded I/O in version 6.0 to mitigate blocking deletions and improve I/O throughput, detailing the underlying event model, code implementations, performance trade‑offs, and comparisons with Tair's threading design.
This article explains Java 8's memory architecture, detailing the differences between JVM-managed memory and native memory, and describing each runtime data area—including the program counter, JVM stack, native method stack, heap, method area, and direct memory—along with common questions about variable storage and native methods.
This article explains the evolution of garbage collection, why G1GC is chosen for low‑latency high‑availability Java services, how it achieves soft real‑time guarantees, the internal heap and region structures, concurrent marking, SATB, remembered sets, and the algorithms used to predict pause times.
This article investigates why MySQL encounters out‑of‑memory errors during sysbench stress testing with high concurrency, examines system memory metrics, explains Linux vm.overcommit_memory settings, and provides a practical solution to prevent OOM by adjusting kernel parameters.
This guide details comprehensive Flink performance tuning techniques, covering memory configuration, GC settings, parallelism adjustments, process parameters, partitioning strategies, Netty network tuning, checkpoint optimization, and common issues such as data skew and resource bottlenecks.
This article explains why reading the ART virtual‑machine source is valuable, compares Dalvik and ART, outlines the GC source hierarchy, details the Space class architecture—including accounting, allocator, collector, and specific spaces like LargeObjectSpace, BumpPointerSpace, and RegionSpace—then analyzes heap construction, PreZygoteFork processing, memory‑map layout, and the full Java‑object allocation flow in ART.
This newsletter highlights two technical articles: one explains JavaScript's memory allocation, stack and heap usage, and garbage‑collection methods with examples of common leaks, while the other details Meituan Waimai's Flutter Web performance challenges and their mitigation strategies.
This article explains Python's memory management by exploring how objects are stored, how references and reference counting work, the role of the garbage collector, generational collection, and how reference cycles are detected and reclaimed.
The article explains how Redis evolves from a single‑threaded in‑memory cache to using Lazy Free and multi‑threaded I/O to alleviate blocking on large key deletions, describing the underlying event model, code implementations, performance trade‑offs, and comparisons with Tair's threading approach.
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 guide explains how to interpret the Linux free command, clarifies the roles of total, used, free, shared, buffers, and cached memory, and provides practical commands to clear swap and drop caches for better system performance.
This article presents a collection of Java best‑practice guidelines—including using the Builder pattern for many constructor arguments, privatizing utility class constructors, minimizing object creation, avoiding finalizers, applying the Law of Demeter, preferring enums, and careful use of var‑args—to improve code readability, memory usage, and runtime performance.
This article presents practical best‑practice guidelines for configuring Elasticsearch in production, covering heap memory sizing, CPU considerations, shard and replica planning, hot‑warm node architecture, node role settings, common pitfalls, monitoring APIs, and troubleshooting tips.
The article details how the C‑end User Mini‑Program for Vivo offline agents was optimized to meet strict performance targets—reducing startup time, white‑screen duration, rendering latency, and memory usage—through code trimming, sub‑packaging, CDN assets, data caching, skeleton screens, and efficient setData handling, achieving faster loads and smoother interaction.
This article explains how Redis handles memory exhaustion by using key expiration commands, describes the three expiration strategies, details the eight maxmemory eviction policies, and dives into the internal LRU and LFU algorithms with their configuration parameters and code examples.
The article explains Android virtual memory concepts, address space limits for 32‑ and 64‑bit apps, layout of QQ Music/Karaoke process memory, tools for inspecting /proc/pid/smaps, and shows how memory growth (e.g., loading libYTCommon.so) can cause 32‑bit apps to hit the 4 GB limit and crash.
Understanding how JavaScript manages memory, this article explains garbage collection concepts such as Stop‑The‑World pauses, reference counting, mark‑sweep, mark‑compact, incremental marking, and V8’s generational strategies, while offering practical code examples and optimization techniques to prevent leaks and improve performance.
This comprehensive guide covers over forty operating system interview questions, explaining core concepts such as OS fundamentals, process and thread management, memory handling, file systems, I/O mechanisms, scheduling algorithms, and deadlock prevention, providing detailed answers and diagrams to help candidates excel in technical interviews.
This comprehensive guide explores Linux’s core concepts—from its UNIX heritage and system architecture to process creation, inter‑process communication, scheduling, virtual memory, file‑system design, I/O handling, networking, loadable modules, and the security model that governs users, permissions and privileged operations.
Learn how to set Redis's maximum memory usage, understand its various eviction policies—including noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, volatile‑random, volatile‑ttl, and the newer LFU strategies—plus see Java code examples and insights into approximate LRU implementation.
This article explains how Redis handles key expiration, the commands for setting TTL, the three expiration strategies, the eight eviction policies, and the internal LRU and LFU algorithms, including their implementation details, sampling techniques, and configuration parameters for memory management.
This article explains how Redis handles key expiration, the commands for setting TTL, the three expiration strategies, the eight memory‑eviction policies, and the internal LRU and LFU algorithms used to manage hot data when memory is exhausted.
This article explains how to set Redis's maximum memory usage, configure eviction policies such as noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, and LFU, demonstrates command‑line and configuration‑file methods, and provides a Java implementation of an LRU cache.
This article introduces the Linux kernel, explains its role as the core of the operating system, details version‑naming conventions and how to interpret kernel version strings, and outlines its main functions such as process, memory, file, device, and network management.
Although malloc is a universal allocator, its lack of scenario-specific optimization makes it unsuitable for high‑performance server applications; this article explains malloc’s internal workflow, compares it with custom memory‑pool techniques, and details various pool designs, thread‑safety strategies, and an interesting cross‑thread free problem.
This article provides a comprehensive overview of MySQL InnoDB's Buffer Pool, explaining its memory layout, data and cache pages, free, flush, and LRU lists, hot‑cold separation, dynamic resizing with chunk mechanisms, and practical configuration tips for production environments.
This article explains how Linux 3.10 organizes memory using NUMA nodes, zones, the buddy system, and the SLAB allocator, providing commands, code examples, and visual diagrams to illustrate each layer of the kernel's efficient memory management.
This article explains the Linux kernel memory management hierarchy—including NUMA nodes, memory zones, the buddy system for free pages, and the SLAB allocator—providing command‑line examples, code snippets, and visual diagrams to illustrate how the kernel efficiently allocates and reclaims memory.
To prevent iOS OOM kills in Gaode Map, developers analyzed Jetsam‑driven physical‑footprint data, identified IOKit, WebKit Malloc, and malloc‑heap as primary consumers, applied graphics texture trimming, shared JavaScriptCore contexts, hooked allocation APIs, and implemented adaptive resource management, achieving roughly 50 % memory reduction and lower crash rates.
This article explains Python’s core principle that everything is an object, detailing the distinction between type objects, instance objects, and metaclasses, how built‑in types like int and str fit into the hierarchy, the role of the object base class, variable naming as pointers, and the differences between mutable, immutable, fixed‑length and variable‑length objects.
This article evaluates Flutter image performance by comparing view reuse, disk‑cache reuse, and memory‑cache reuse strategies, detailing implementation hurdles, and ultimately finds that a Texture‑based approach offers fast communication yet consumes more memory than the native Image widget’s on‑demand decoding.
This article explains the fundamentals of operating‑system memory management, covering physical memory limits, the need for address spaces, base‑limit protection, paging, virtual memory mapping, page‑fault handling, and a comprehensive review of page‑replacement algorithms such as FIFO, LRU, Clock, and Working‑Set.
This comprehensive guide explains the JVM memory layout, object allocation, garbage collection mechanisms such as mark‑sweep, copying, and mark‑compact, details GC roots, reference types, collector types, tuning parameters, and related Java performance tools, providing practical code examples and diagrams.
This article explains the different types of Java garbage collectors, focuses on the G1 (Garbage‑First) collector’s region‑based architecture, key data structures and algorithms such as TLAB, PLAB, CSet, Card Table, RSet, and SATB, and provides detailed log analysis and tuning recommendations to improve pause times and throughput.
This comprehensive guide explores Java's JVM internals, covering memory leaks, data type sizes, differences between Serial and Parallel GC, reference types, compressed OOPs, JVM bitness detection, heap limits, JRE/JDK/JVM/JIT distinctions, memory regions, garbage collection algorithms, class loading mechanisms, and practical tuning commands and tools, providing developers with deep insights into Java performance and memory management.
This article provides a comprehensive overview of the Java Virtual Machine, covering its runtime data areas, the Java Memory Model, heap organization, garbage‑collection algorithms, HotSpot implementation details, JVM tuning parameters, and the class‑loading mechanism.
This article explains how Objective‑C objects are deallocated in both manual reference counting (MRC) and Automatic Reference Counting (ARC), outlines common pitfalls such as using __weak in dealloc, and details the runtime flow from _objc_rootDealloc to the final memory free operation.
This article explains the architecture of browser engines, the distinction between stack and heap memory, V8's generational garbage collection strategies—including the Scavenge algorithm for the young generation and mark‑sweep/mark‑compact for the old generation—along with optimizations such as write barriers, incremental marking, and parallel/concurrent collection.
This article introduces the Java Virtual Machine’s overall architecture and its runtime data areas, covering class files, class loaders, execution engine components, native interfaces, and detailed explanations of the program counter, stacks, heap, method area, and constant pool, providing a solid foundation for Java developers.
This article presents thirteen practical Redis performance‑optimization rules—covering command complexity, key expiration, data structures, persistence, hardware choices, clustering, memory fragmentation, and client‑side techniques—to help developers identify bottlenecks and boost throughput and latency in production environments.
This article investigates how large a single Redis instance can be on a 64 GB server, explains the NUMA memory‑allocation trap, and documents experiments that compare unbound versus CPU‑memory‑affinity‑bound deployments, revealing when swap and OOM occur.
Tailor is an open‑source Android memory‑snapshot trimming and compression tool developed by the Xigua Video team that dramatically reduces OOM occurrences by over 95% through efficient snapshot cropping, zlib compression, and seamless integration with the dump process, while preserving essential debugging information.
This article explains Linux HugePages, how to view and configure them, demonstrates code and Kubernetes examples, and details how larger memory pages reduce management overhead and lock memory to improve performance for memory‑intensive services like databases and Hadoop.
This article explains the core principles of DPDK memory management, covering standard huge pages, NUMA node binding, direct memory access, IOMMU and IOVA addressing, custom allocators, and memory pools, and how these mechanisms together enable high‑performance packet processing on Linux systems.
This article explains Java's four reference types—strong, soft, weak, and phantom—detailing their purposes, behavior during garbage collection, and practical code examples that demonstrate how each reference influences object lifecycle and memory management.
This guide explains seven critical Linux operating‑system settings—memory overcommit, swappiness, Transparent Huge Pages, OOM killer, NTP synchronization, ulimit, and TCP backlog—that together ensure Redis runs reliably and at peak speed.
This article provides an in‑depth technical guide to Linux, covering its Unix heritage, process and thread creation, kernel architecture, virtual memory, scheduling algorithms, file‑system structures, I/O handling, networking, and built‑in security mechanisms such as user IDs, permissions, and set‑UID features.
This article introduces fundamental operating‑system concepts—including processes, address spaces, file systems, I/O devices, protection mechanisms, and virtual memory—explaining their roles, state models, and how they enable reliable communication between hardware and application software.
This article explains common causes of Redis latency spikes, such as high‑complexity commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network saturation, and provides step‑by‑step troubleshooting commands and best‑practice recommendations.
This article explains how Python's dynamic objects consume hidden memory, demonstrates measuring object sizes with sys.getsizeof and a recursive get_size function, and shows how using __slots__ can dramatically reduce memory footprints while discussing trade‑offs and practical code examples.
This article explains Linux process memory organization, detailing how task_struct and mm_struct describe virtual memory, the role of vm_area_struct for each segment, page table interactions, and the lazy allocation mechanism that maps physical memory only on page faults.
This article provides an in‑depth tutorial on Linux fundamentals, covering the kernel architecture, process and thread creation, inter‑process communication, scheduling algorithms, virtual memory management, paging, caching, file system structures (VFS, ext2/ext4), network file systems, I/O device handling, loadable modules, and the operating‑system security model with permissions and setuid mechanisms.
This article investigates why MySQL often consumes far more physical memory than the configured InnoDB buffer pool size, explains the high‑water‑mark effect, and explores Linux process memory layout, memory allocators, and MySQL’s internal memory management mechanisms.
