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.
This comprehensive guide breaks down the four main parts of a Linux system—kernel, shell, filesystem and applications—detailing kernel subsystems such as memory and process management, shell variants, file types, directory hierarchy, partition handling, VFS, mounting procedures, link types and essential command‑line tools, while also touching on application bundles and kernel parameter tuning.
This article provides a comprehensive overview of the Java Virtual Machine memory layout, explaining the roles and allocation strategies of the heap, metaspace, stack frames, program counter, direct memory, and code cache, and includes practical code examples for heap tuning and OOM demonstration.
This article examines typical Redis latency spikes—such as complex O(n) commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, and network saturation—explaining how to detect, monitor, and mitigate each issue to maintain high‑performance operation.
This article explains the design and evolution of Redis's Simple Dynamic Strings (SDS), covering the original pre‑3.2 structure, the newer type‑specific headers, the core API functions for creating, clearing, and concatenating SDS objects, and the memory‑reallocation strategy that ensures binary safety and efficient storage.
This article consolidates practical Elasticsearch tuning techniques—including configuration file adjustments, system‑level optimizations, and usage‑level settings—to improve cluster performance, stability, and resource efficiency for production environments.
This article explains how Java's String.intern method interacts with the string constant pool, detailing the differences between JDK6, JDK7, and JDK8 implementations, and walks through multiple code examples that show why strings that were originally unequal become identical after interning.
This article explains the functions and storage locations of Java's runtime constant pool, string constant pool, and static constant pool across different JDK versions, illustrating JVM memory layout, constant pool structures, and how they evolve from PermGen to Metaspace.
This article dissects the Java String creation process, explaining how the constant pool and heap interact, why new String("abc") can generate one or two objects, and how string concatenation and StringBuilder affect the total number of objects created during runtime.
This article explains the distinction between Linux Buffers and Cache, how they appear in the free command, their representation in /proc/meminfo, and demonstrates practical experiments using vmstat and dd to observe their behavior during read and write operations, concluding with clear usage guidelines.
This article explains how different Android versions handle image memory, clarifies screen size, density, and resolution concepts, shows how folder placement and bitmap formats affect RAM usage, and provides practical Glide configuration to prevent out‑of‑memory crashes.
This article explains how to configure Redis's maximum memory usage, describes the built‑in eviction strategies such as noeviction, allkeys‑lru, volatile‑lru, random and ttl policies, shows how to query and set these policies via configuration files or runtime commands, and details the LRU and LFU algorithms used by Redis, including Java sample code and recent improvements in Redis 3.0 and 4.0.
This article presents a comprehensive collection of JVM interview questions covering memory areas, garbage collection, class loading, and performance tuning, along with eleven detailed Java mind‑map images that visually summarize core concepts such as the JVM architecture, GC algorithms, and thread management.
This article provides a comprehensive overview of Oracle Database Management System, covering its overall architecture, instance concepts, process structures, memory components, configuration schemes, program interfaces, data dictionary organization, and transaction handling mechanisms.
Redis, an in‑memory key‑value store, lets you set a maximum memory limit via configuration files or runtime commands, choose among various eviction strategies such as noeviction, allkeys‑lru, volatile‑lru, and LFU, and understand how approximate LRU works, with Java code examples illustrating these concepts.
This article explains Spark's transition from static to unified memory management, detailing on‑heap and off‑heap memory regions, key configuration parameters, dynamic allocation behavior, and legacy mode, helping users optimize executor memory usage for both batch and streaming workloads.
This article explains how to configure Redis's maximum memory usage, modify memory limits at runtime, understand the built‑in eviction strategies—including noeviction, allkeys‑lru, volatile‑lru, allkeys‑random, volatile‑random, and volatile‑ttl—how to query and set these policies, and the details of LRU and LFU algorithms with Java examples and performance comparisons.
This article explains the various OutOfMemoryError variants in the Java Virtual Machine, illustrates each with reproducible code examples, analyzes root causes, and provides practical mitigation strategies such as JVM flags, code refactoring, and system‑level adjustments.
This article analyzes Apache Spark's executor-side memory management model, focusing on the UnifiedMemoryManager in Spark 2.2.1, detailing on‑heap and off‑heap memory regions, dynamic execution/storage memory sharing, task memory allocation, and practical configuration examples.
This article provides a comprehensive overview of Spark's memory management, covering executor memory architecture, the differences between on‑heap and off‑heap memory, static versus unified memory managers, storage and execution memory handling, and practical guidelines for optimizing Spark applications.
This article provides a comprehensive overview of the Java Virtual Machine's runtime data areas—including the program counter, JVM stack, native method stack, heap, and method area—explaining their structures, lifecycles, related JVM flags, garbage‑collection strategies, TLAB, and escape‑analysis optimizations.
This comprehensive guide explores Linux memory fundamentals, address space layout, fragmentation, buddy and slab allocation algorithms, kernel and user‑space memory pools, DMA handling, common pitfalls in C/C++ memory management, and practical commands for monitoring and debugging memory usage on Linux systems.
This article explains how to read large files in Java without running out of memory by comparing full‑file loading, line‑by‑line reading using BufferedReader, Apache Commons IO, and Java 8 streams, and shows how to boost throughput with batch processing and multithreaded file splitting.
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 provides a comprehensive overview of Java Virtual Machine runtime data areas, the Java Memory Model, heap memory segmentation, garbage collection algorithms, HotSpot VM details, and class loading mechanisms, offering practical insights for performance tuning and system design.
This article explains Linux's memory architecture, the role of virtual memory and swap, the distinction between buffers and cache, and provides practical commands to adjust swappiness, clear caches, and safely release both RAM and swap space for improved system performance.
This article explains the differences between Java's heap and stack memory areas, their advantages and disadvantages, and demonstrates how string objects are allocated and shared with clear code examples that illustrate memory usage and performance implications.
This article provides a comprehensive guide to Linux memory management, covering the memory organization, address spaces, fragmentation causes and mitigation, the buddy and slab allocation algorithms, kernel and user‑space memory pools, common pitfalls, and practical tools for monitoring and debugging memory usage.
In a mobile‑first world where limited device resources and unstable networks threaten user retention, Kuaishou’s performance team built an APM monitoring platform and applied systematic memory, startup, and jank optimizations that cut startup time by 40%, reduced package size by 23 MB, and significantly improved key product metrics.
This article explains why virtual memory is essential in modern operating systems, covering its role as an abstraction layer, caching benefits, memory protection, multi‑level page tables, and how it enables efficient resource utilization and process isolation.
This article provides a comprehensive overview of the Java Virtual Machine (JVM) architecture, detailing its garbage collection mechanisms, class‑loader subsystem, execution engine, runtime data areas, and common GC command‑line options, offering essential knowledge for Java developers.
This article explains how CPython implements its own memory‑management scheme—including the layered allocation model, pool and arena structures, block size classes, and reference‑count‑based reclamation—by dissecting the source code of Python 2.7’s obmalloc module.
This article explains the JVM's memory layout, including method area, heap, stack, PC register, and native method stack, and details garbage collection concepts such as marking, deletion, compaction, generational GC, and the characteristics of various collectors like Serial, Parallel, CMS, and G1.
This guide explores Redis key expiration policies—including active, lazy, and periodic expiration—memory eviction strategies, resource consumption, thread model, and transaction mechanisms, providing practical insights on configuring TTL, optimizing memory usage, and understanding Redis’s single‑threaded architecture for reliable data handling.
This article explains how to configure Redis's maximum memory usage, describes the various eviction strategies such as noeviction, allkeys‑lru, volatile‑lru, and introduces both LRU and LFU algorithms with Java examples and practical configuration commands.
This article explains how Redis uses memory, covering memory fragmentation analysis, object and buffer memory consumption, sub‑process memory overhead, and practical configuration of maxmemory limits and eviction policies to optimize performance and prevent out‑of‑memory failures.
This article explains how to configure Redis's maximum memory usage, describes the various eviction strategies including noeviction, allkeys‑lru, volatile‑lru, random and ttl policies, shows how to query and set these policies via configuration files or commands, and provides Java code for a simple LRU cache while discussing Redis's approximate LRU and LFU algorithms.
This article explains, with concrete Java examples and JVM runtime‑stack analysis, why manually assigning null to objects that are out of scope does not always trigger earlier garbage collection, and how stack slot reuse can achieve the same effect without relying on a questionable practice.
This comprehensive guide explains over 190 fundamental operating system and computer architecture concepts—including OS kernels, memory management, process control, virtualization, storage, networking, and security—providing clear definitions, examples, and visual illustrations to help readers grasp the core building blocks of modern computing systems.
This article explains how Linux maps logical to physical addresses, describes the buddy and slab memory allocation mechanisms, outlines their limitations and improvements such as slub and vmalloc, and details the page‑fault handling process including registers involved and swap behavior.
This article explains why explicitly assigning null to objects that are no longer used can help Java's garbage collector reclaim memory, explores JVM stack slot behavior, demonstrates the effect with code examples, and clarifies common misconceptions about this practice.
This article examines why MySQL instances are often targeted by the Linux OOM killer, explains proper InnoDB buffer pool sizing, introduces memory leak concepts, and demonstrates how to use Valgrind's Memcheck tool to detect leaks and improve database memory management.
Learn how to dramatically boost Redis speed by shortening key/value sizes, enabling lazy free, setting expirations, disabling costly commands, using slowlog, pipelines, avoiding mass expirations, optimizing clients, limiting memory, running on physical servers, tweaking persistence, disabling THP, and adopting distributed architectures.
This article presents nine frequently asked Python interview questions covering lists, tuples, dictionaries, string reversal, memory management, session/cookie/token concepts, HTTP methods, decorators, concurrency, comprehensions, and generators, each explained with clear descriptions and code examples for developers preparing for technical interviews.
This article provides an extensive overview of Java Virtual Machine fundamentals for interview preparation, covering JVM components, runtime data areas, heap vs. stack memory, garbage collection mechanisms, algorithms, collectors, memory allocation strategies, class loading processes, and tuning tools.
This article provides an in‑depth overview of Go's garbage collector, covering its design principles, mark‑sweep algorithm, tri‑color abstraction, write‑barrier techniques, incremental and concurrent collection, evolution across Go versions, and detailed implementation details of marking, sweeping, and memory reclamation.
This article explains how to use Linux commands like free and sync to view and clear buffer/cache memory, describes the information shown by free, and then dives into SQL join types, their performance impact, and optimization techniques such as indexing, join_buffer tuning, and join algorithms.
This article examines production JVM memory architecture, explains GC log generation and analysis, details the ParNew + CMS collector behavior, and provides practical parameter tuning recommendations to optimize heap size, young generation, and garbage collection for stable Java applications in production environments.
This article provides a comprehensive overview of operating system fundamentals and computer architecture, covering topics such as OS components, kernel and user modes, memory management, process handling, hardware interfaces, storage hierarchies, virtualization, and related historical and modern systems in roughly eighty concise entries.
Learn how to optimize Java applications by configuring six critical JVM parameters—including heap size, Metaspace limits, GC algorithm selection, logging, heap dumps, thread stack size, and network timeouts—while understanding their impact on performance, memory usage, and troubleshooting common out‑of‑memory issues.
Learn how to dramatically improve Redis performance by shortening key-value sizes, enabling lazy free, setting expirations, disabling costly commands, using slowlog, leveraging pipeline, preventing mass expirations, optimizing client connections, limiting memory, running on physical servers, configuring persistence, disabling THP, and adopting distributed architectures.
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.
This article explains Redis's memory model by describing how to query memory usage, the roles of used_memory, used_memory_rss, mem_fragmentation_ratio, and mem_allocator, and then dives into the internal structures such as redisObject, SDS, jemalloc, and the encoding strategies for strings, lists, hashes, sets, and sorted sets.
This article explains how Linux memory statistics (free, top) report buffer/cache usage, how to clear it with sync and drop_caches, and then dives into SQL join concepts, types, optimization techniques, and MySQL join algorithms such as nested loop and block nested loop, highlighting their impact on performance.
FlutterBoost 2.0 redesigns the hybrid architecture by assigning each Flutter page its own controller and view, eliminating screenshot‑based transitions, fixing white/black screen glitches, enhancing iOS surface management and lifecycle callbacks, adding extensive documentation and tests, while acknowledging a ~10 MB per‑page memory cost mitigated through stack limits and reuse.
The article explains Spark’s executor memory layout under the UnifiedMemoryManager, detailing on‑heap and off‑heap divisions, the four memory regions, default fraction settings, how storage and execution memory share space, and provides heuristics and tuning tips for avoiding OOM and optimizing performance.
This article explains how to optimize HBase performance by properly configuring JVM memory, selecting suitable garbage‑collection strategies, enabling MSLAB and BucketCache, and adjusting read/write cache ratios to reduce fragmentation and improve throughput.
This comprehensive guide explains the fundamentals of operating systems, covering hardware components, CPU architecture, memory hierarchy, process and address space management, file systems, system calls, and various OS structures such as monolithic, layered, microkernel, and client‑server designs, providing clear examples and diagrams for each concept.
This article provides a comprehensive overview of Java's automatic garbage collection, covering memory regions, identification methods, core algorithms such as mark‑sweep, copying, and generational collection, detailed explanations of various collectors (Serial, CMS, G1, etc.), and practical tuning insights for optimal performance.
This article explores Redis, a high‑performance in‑memory key‑value store, detailing its core data types—String, List, Hash, Set, ZSet—the underlying structures such as SDS, quicklist, hashtable, and intset, and demonstrates practical usage patterns like caching, rate limiting, and inventory control.
The article clarifies frequent iOS development misconceptions—from unnecessary observer removal and deprecated NSUserDefaults synchronization to block retain‑cycle tricks, responder‑chain versus hit‑testing differences, GCD queue optimizations, safe main‑queue detection, and proper cancellation of dispatch blocks—offering practical code guidance.
A Java backend service crashed during testing due to excessive Full GC events caused by unbounded queries that retrieved over 40,000 records, leading to massive List allocations, old‑generation memory pressure, and ultimately service failure.
This article reviews nine frequently asked Python interview questions, covering lists, tuples, dictionaries, string reversal, memory management, sessions, cookies, tokens, GET vs POST, decorators, concurrency concepts, comprehensions, and generators, providing concise explanations and code examples.
This guide explains the most important JVM parameters—such as -Xms, -Xmx, -Xss, and various -XX options—detailing how each setting influences heap, stack, and generation sizes and how proper configuration can avoid common OutOfMemoryError scenarios in Java applications.
This article provides an in‑depth overview of Redis, covering why it is used for performance and concurrency, its single‑threaded architecture, core data structures and their scenarios, expiration policies, memory eviction strategies, consistency challenges, and practical solutions for cache penetration, snowballing, and concurrent key updates.
This article explains why the memory reported by ps RSS differs from the free command, walks through interpreting free -m output, demonstrates clearing caches, and shows how to account for process RSS, slab allocations, and PageTables to reconcile total used memory on Linux systems.
This article provides a comprehensive overview of the Java Virtual Machine memory layout, covering heap regions, Metaspace, stack frames, native method stack, program counter, direct memory, and code cache, along with configuration tips, diagnostic commands, and illustrative code examples to help readers understand memory allocation and garbage collection.
The article introduces Tencent’s open‑source Hippy cross‑platform framework, outlines its developer‑friendly features and W3C compliance, and details common debugging techniques—including Chrome DevTools‑based services, jsbundle debugging, and memory monitoring—while presenting practical troubleshooting cases for UI updates, scrolling, performance, and iOS‑specific issues.
