This article explains what Objective‑C blocks are, why they are useful, how to declare and use them in various contexts, and dives into the compiler‑generated data structures, copy/dispose mechanisms, __block semantics, memory‑management pitfalls, and reference‑cycle avoidance.
This article explains the fundamentals of virtual memory, including paging, page tables, swap, and Linux management commands, highlighting how virtual memory abstracts physical addresses, resolves process memory conflicts, and enhances security and data sharing while providing practical tips for monitoring and tuning memory usage.
This article provides a comprehensive, interview‑focused guide to the Java Virtual Machine, covering memory regions, garbage‑collection algorithms, reference types, GC roots, STW pauses, OopMap, safe points, stack overflow, class loading, the parent‑delegation model, stack allocation, and object layout, all with clear explanations and diagrams.
This article explores several lesser‑known Python standard‑library techniques—including string sanitization, iterator slicing with itertools.islice, skipping initial lines, enforcing keyword‑only arguments, creating custom context managers, using __slots__ for memory savings, limiting CPU/memory via the resource module, controlling module exports with __all__, and simplifying comparisons with functools.total_ordering.
This article outlines five typical C programming mistakes—uninitialized variables, array out‑of‑bounds access, string overflow, double free, and invalid file pointers—explaining why they occur, showing concrete code examples with varied outputs, and offering practical safeguards to prevent them.
This article lists five common C programming mistakes—uninitialized variables, array out‑of‑bounds access, string overflow, double free, and invalid file pointers—explains why they occur, shows concrete code examples with typical output, and offers practical ways to prevent each bug.
This article explains how the JVM determines object liveness, describes reference counting and reachability analysis, lists GC Roots, and provides clear visual and code examples of the main garbage‑collection algorithms—mark‑sweep, copy, mark‑compact, and generational collection—highlighting their advantages, drawbacks, and typical use cases.
This article provides a comprehensive overview of the Java Virtual Machine, explaining its main purpose, memory regions, class‑loading mechanism, object creation process, memory allocation strategies, object layout, reference handling, garbage‑collection theories, algorithms, and common JVM tuning commands.
This article explains the motivation behind Netty's FastThreadLocal, compares it with JDK ThreadLocal, details its internal implementation—including InternalThreadLocalMap, FastThreadLocalThread, and key methods like get()—and discusses its performance benefits, resource recycling mechanisms, and practical usage in Netty's ByteBuf allocation.
This article provides a comprehensive overview of the Java Virtual Machine memory architecture, covering heap layout, allocation, tuning parameters, garbage collection, stack frames, method area, metaspace, native method stack, program counter, direct memory, and code cache, with practical code examples and diagnostics.
This article explains how Linux allocates memory for a process, the role of OOM when memory runs out, where different types of memory reside, the behavior of shared and private mappings, tmpfs usage, and both manual and automatic memory reclamation mechanisms.
This article explains Linux kernel memory management by covering process address space layout, allocation mechanisms, OOM killer behavior, overcommit settings, various types of file and anonymous mappings, tmpfs usage, and both manual and automatic memory reclamation techniques.
This guide explains what Linux swap is, its advantages and drawbacks, how to size it for different memory configurations, and provides step‑by‑step commands for creating, managing, and tuning swap partitions or files, including swappiness and ZFS considerations.
This guide explains the most common JVM startup flags for controlling garbage collection logging, heap sizing, class loading monitoring, and out‑of‑memory handling, providing sample outputs and detailed interpretations to help developers tune memory usage and diagnose performance issues in large Java applications.
This article explains what large (huge) pages are, why they improve JVM performance, and provides step‑by‑step instructions for configuring Transparent Huge Pages and HugeTLB pages on Linux as well as enabling large pages on Windows, including verification techniques.
This article explains why using @Async in Spring Boot can cause memory overflow when many requests trigger parallel tasks, examines the default thread‑pool settings that lead to unbounded queues, and provides step‑by‑step configuration of a safe thread pool to prevent out‑of‑memory failures.
This article provides a comprehensive JavaScript guide covering primitive and reference types, Symbol and BigInt nuances, type‑checking operators, stack vs heap memory, deep and shallow copying techniques, and practical garbage‑collection strategies to help developers ace interview questions.
This article investigates a deadlock between the Main Thread and the JavaScriptCore Heap Collector Thread on iOS 13, explains the underlying mutex and RunLoop interactions, reproduces the issue with CFTimer‑based timers, and proposes an AutoReleasePool‑wrapped solution along with best‑practice recommendations for JavaScriptCore usage.
This article provides a comprehensive overview of the Java Virtual Machine memory layout, explaining each region such as the heap, metaspace, stack, program counter, direct memory and code cache, along with allocation strategies, tuning parameters, and practical OOM demonstrations.
This article explains Flink's memory architecture, covering on‑heap and off‑heap memory concepts, garbage collection, allocation strategies, memory segments, buffers, the memory manager, and how network transmission and back‑pressure are handled to achieve efficient streaming processing.
This article explores obscure Android thread issues—including uncontrolled thread creation, stack memory leaks, and the impact of thread‑priority settings—while presenting monitoring techniques, a pthread hook implementation, and performance considerations to help developers detect and resolve thread‑related crashes.
This comprehensive guide covers Java platform basics, JVM/JRE/JDK relationships, bytecode advantages, new features since Java 8, core OOP principles, common interview questions, exception handling, garbage collection, reference types, and practical code examples to solidify your Java expertise.
This article explains how to avoid out‑of‑memory errors during massive data migrations by choosing appropriate Spring Batch readers, comparing JdbcCursorItemReader and JdbcPagingItemReader, and showing code examples and memory‑usage diagrams.
This article explains how Java objects are stored in memory, covering the object header, instance data, alignment padding, lock states, pointer compression, and field reordering, and demonstrates how to inspect these structures using the OpenJDK JOL tool with practical code examples.
An in‑depth analysis of a memory‑growth issue observed in a Kuaishou live‑stream app reveals how ARC, autorelease pools, and NSString’s class‑cluster implementation interact, why @autoreleasepool blocks resolve the leak, and how compiler optimizations and thread‑local pools affect object release in long‑running C++ threads.
This article explains how to identify oversized Redis keys, analyze their impact with built‑in commands and third‑party tools, and safely remove them using UNLINK and lazy‑free configurations to prevent performance bottlenecks.
This article walks through common interview questions on Linux memory inspection and cache clearing, explains the fields shown by the free command, and then delves into SQL join types, performance bottlenecks, buffer settings, and practical optimization techniques for MySQL databases.
After a network disruption caused Paxos messages to be ignored and memory shortages prevented data migration, this article details how the Aerospike cluster became unavailable, the diagnostic logs, and the step‑by‑step remediation involving node restarts, memory tuning, and adding new nodes for load balancing.
Redis latency spikes can stem from complex commands, large keys, concentrated expirations, memory limits, fork overhead, CPU binding, AOF settings, swap usage, or network saturation, and this guide explains how to identify, monitor, and mitigate each cause using slowlog, bigkeys, info, and configuration tweaks.
This article introduces the most frequently used JVM startup parameters, explains their effects on garbage collection, heap configuration, class loading monitoring, and out‑of‑memory handling, and provides example outputs to help developers tune Java applications for large‑scale projects.
This article explains the two types of Linux huge pages—static HugeTLB pages and dynamic Transparent Huge Pages—detailing their sizes, performance advantages, drawbacks, especially for Oracle workloads, and provides step‑by‑step instructions for checking status and permanently disabling THP via sysfs or GRUB.
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.
The article details MOO Music’s experience with Flutter memory management, explaining the Dart heap, stack, and external memory structures, common leak sources such as missing listener deregistration, unbounded widget lists, retained timers, static references, and third‑party or engine bugs, and offers practical detection and optimization techniques.
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.
