Tagged articles

Memory Management

1009 articles · Page 7 of 11
Efficient Ops
Efficient Ops
Dec 15, 2021 · Fundamentals

Understanding Linux: Kernel, Shell, Filesystem, and Process Management

This article provides a comprehensive overview of Linux system architecture, covering the kernel, memory and process management, virtual and physical filesystems, device drivers, networking, shell types, file types, directory structures, partitioning, mounting, and link mechanisms, all illustrated with diagrams and command examples.

FilesystemLinksLinux
0 likes · 35 min read
Understanding Linux: Kernel, Shell, Filesystem, and Process Management
BaiPing Technology
BaiPing Technology
Dec 14, 2021 · Frontend Development

Why Vue 3 Relies on WeakMap for Reactivity and Memory‑Safe Caching

This article explains how Vue 3 uses a WeakMap as a cache to avoid duplicate proxies, why WeakMap is preferred over Map for memory‑safe reactive objects, and explores WeakMap fundamentals, its methods, garbage‑collection strategies, and practical applications such as DOM storage and private class fields.

Garbage CollectionMemory ManagementWeakMap
0 likes · 13 min read
Why Vue 3 Relies on WeakMap for Reactivity and Memory‑Safe Caching
Python Crawling & Data Mining
Python Crawling & Data Mining
Dec 12, 2021 · Fundamentals

Unlock Python’s Numeric Types: Integers, Floats, Complex & Memory Tricks

This article explains Python’s numeric types—including integers, floats, and complex numbers—covers their immutability, memory representation such as the small integer object pool, demonstrates type conversion functions, and introduces the math library for basic scientific calculations, all illustrated with clear code examples.

FloatsIntegersMath Library
0 likes · 9 min read
Unlock Python’s Numeric Types: Integers, Floats, Complex & Memory Tricks
Big Data Technology & Architecture
Big Data Technology & Architecture
Dec 6, 2021 · Big Data

Understanding Spark’s Memory Model: Unified Memory Management, On‑Heap and Off‑Heap Memory, and Configuration

This article explains Spark’s unified memory management model, detailing the division between on‑heap and off‑heap memory, the roles of execution, storage, user, and reserved memory, configuration parameters, dynamic allocation, and how these concepts affect performance and resource utilization.

Execution MemoryMemory ManagementOff-Heap
0 likes · 17 min read
Understanding Spark’s Memory Model: Unified Memory Management, On‑Heap and Off‑Heap Memory, and Configuration
Java High-Performance Architecture
Java High-Performance Architecture
Dec 3, 2021 · Fundamentals

Unlocking JVM Secrets: Deep Dive into Memory, GC, Class Files, and Method Dispatch

This comprehensive guide explores the inner workings of the Java Virtual Machine, covering memory regions, garbage‑collection algorithms, class‑file structure, bytecode instructions, class loading mechanisms, and method dispatch strategies, providing clear explanations and code examples for developers seeking a deeper understanding of JVM fundamentals.

Garbage CollectionJVMMemory Management
0 likes · 41 min read
Unlocking JVM Secrets: Deep Dive into Memory, GC, Class Files, and Method Dispatch
Python Programming Learning Circle
Python Programming Learning Circle
Dec 2, 2021 · Fundamentals

Understanding Python Garbage Collection: Reference Counting, Mark‑Sweep, and Generational GC

This article explains how Python’s automatic garbage collection works, covering reference counting, the problems of cyclic references, the mark‑and‑sweep algorithm, generational collection, default thresholds, and when and how to manually control the collector with code examples.

Garbage CollectionGenerational GCMark‑Sweep
0 likes · 7 min read
Understanding Python Garbage Collection: Reference Counting, Mark‑Sweep, and Generational GC
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Nov 26, 2021 · Fundamentals

Understanding V8 Engine Memory Allocation and Garbage Collection

This article explains how the V8 JavaScript engine allocates memory, why garbage collection is necessary, describes the memory layout of new and old generations, reviews common GC algorithms such as reference counting, mark‑sweep, mark‑compact and incremental marking, and offers practical tips for writing high‑performance JavaScript code.

Garbage CollectionJavaScriptMemory Management
0 likes · 22 min read
Understanding V8 Engine Memory Allocation and Garbage Collection
Code Ape Tech Column
Code Ape Tech Column
Nov 25, 2021 · Backend Development

Comprehensive Guide to JVM Memory Areas, Garbage Collection, and Related Concepts

This article provides an in‑depth overview of the JVM runtime data structures, memory regions, garbage‑collection algorithms, GC roots, reference types, stop‑the‑world pauses, OopMap, safe points, stack‑overflow handling, class‑loading mechanisms, the parent‑delegation model, object stack allocation, and object layout, offering practical insights for Java developers preparing for interviews.

Garbage CollectionJVMJava
0 likes · 29 min read
Comprehensive Guide to JVM Memory Areas, Garbage Collection, and Related Concepts
Practical DevOps Architecture
Practical DevOps Architecture
Nov 23, 2021 · Fundamentals

Understanding Memory Leaks, Memory Overflow, Young GC STW, Major vs Full GC, and Direct Memory in Java

This article explains the difference between memory leaks and overflow, whether young GC triggers stop‑the‑world pauses, distinguishes major GC from full GC, and describes Java's direct memory usage, providing clear insights into Java memory management and performance considerations.

Garbage CollectionMemory Managementdirect-memory
0 likes · 4 min read
Understanding Memory Leaks, Memory Overflow, Young GC STW, Major vs Full GC, and Direct Memory in Java
Programmer DD
Programmer DD
Nov 19, 2021 · Fundamentals

Mastering JVM Memory and Garbage Collection: A Comprehensive Guide

This article provides an in-depth exploration of Java's JVM memory architecture, garbage collection algorithms, class file structure, class loading process, bytecode execution, and method dispatch mechanisms, offering practical code examples and visual diagrams to help developers understand and optimize JVM performance.

Garbage CollectionJVMJava
0 likes · 44 min read
Mastering JVM Memory and Garbage Collection: A Comprehensive Guide
Architects' Tech Alliance
Architects' Tech Alliance
Nov 17, 2021 · Fundamentals

Understanding Operating System Evolution, Boundaries, and Memory Management

The article explains how operating systems acquire execution control, traces their historical evolution from early mainframes to modern mobile platforms, and details memory management techniques in real and protected modes, highlighting the roles of BIOS, boot loaders, virtual memory, and the shifting boundaries between hardware, OS, and browsers.

Boot ProcessMemory ManagementVirtual Memory
0 likes · 20 min read
Understanding Operating System Evolution, Boundaries, and Memory Management
Architect
Architect
Nov 10, 2021 · Fundamentals

Deep Dive into JVM: Class Loading, Memory Management, Debugging, Hot Deployment, and Performance Tuning

This comprehensive article explains the inner workings of the Java Virtual Machine, covering class file structure, class loaders, memory layout, garbage collection, execution engine, debugging via JPDA, hot deployment, hot swapping, and performance tuning techniques, providing practical code examples and configuration tips.

JVMMemory ManagementPerformance Tuning
0 likes · 74 min read
Deep Dive into JVM: Class Loading, Memory Management, Debugging, Hot Deployment, and Performance Tuning
Su San Talks Tech
Su San Talks Tech
Nov 8, 2021 · Fundamentals

Mastering JVM Memory: Layout, GC Algorithms, and Tuning Tips

This comprehensive guide explains the JVM memory layout, class‑loading and object‑creation process, the parent‑delegation model, various garbage‑collection algorithms and collectors, GC roots, triggers for YGC and Full GC, and practical tuning parameters to improve Java application performance.

Garbage CollectionJVMMemory Management
0 likes · 15 min read
Mastering JVM Memory: Layout, GC Algorithms, and Tuning Tips
Laravel Tech Community
Laravel Tech Community
Nov 2, 2021 · Operations

Understanding Virtual Memory: Concepts, Paging, and Management in Linux

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.

LinuxMemory ManagementPage Table
0 likes · 9 min read
Understanding Virtual Memory: Concepts, Paging, and Management in Linux
JavaEdge
JavaEdge
Oct 31, 2021 · Backend Development

Master JVM Memory & GC: 20 Essential Interview Questions Explained

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.

Garbage CollectionJVMJava
0 likes · 31 min read
Master JVM Memory & GC: 20 Essential Interview Questions Explained
Python Programming Learning Circle
Python Programming Learning Circle
Oct 30, 2021 · Fundamentals

Lesser‑Known Python Standard Library Features and Techniques

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.

IteratorsMemory Managementcontext-managers
0 likes · 7 min read
Lesser‑Known Python Standard Library Features and Techniques
ITPUB
ITPUB
Oct 28, 2021 · Fundamentals

5 Common C Bugs Every Programmer Should Avoid

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.

C ProgrammingMemory Managementarray bounds
0 likes · 13 min read
5 Common C Bugs Every Programmer Should Avoid
Liangxu Linux
Liangxu Linux
Oct 26, 2021 · Fundamentals

5 Sneaky C Bugs Every Programmer Should Avoid

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.

C ProgrammingInitializationMemory Management
0 likes · 13 min read
5 Sneaky C Bugs Every Programmer Should Avoid
JavaEdge
JavaEdge
Oct 26, 2021 · Fundamentals

Master Java Garbage Collection: Visual Guide to Algorithms and Roots

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.

GC AlgorithmsGarbage CollectionJVM
0 likes · 12 min read
Master Java Garbage Collection: Visual Guide to Algorithms and Roots
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 13, 2021 · Fundamentals

JVM Core Concepts: Memory Areas, Class Loading, Object Creation, and Garbage Collection

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.

Garbage CollectionJVMJava
0 likes · 51 min read
JVM Core Concepts: Memory Areas, Class Loading, Object Creation, and Garbage Collection
Programmer DD
Programmer DD
Oct 13, 2021 · Backend Development

Why Netty Introduced FastThreadLocal and How It Works

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.

FastThreadLocalJavaMemory Management
0 likes · 13 min read
Why Netty Introduced FastThreadLocal and How It Works
Top Architect
Top Architect
Oct 6, 2021 · Fundamentals

Understanding JVM Memory Layout and 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.

JVMJavaMemory Management
0 likes · 16 min read
Understanding JVM Memory Layout and Allocation
Efficient Ops
Efficient Ops
Sep 27, 2021 · Fundamentals

How Linux Kernel Manages Memory: Allocation, OOM, and Recovery

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.

LinuxMemory ManagementOOM
0 likes · 20 min read
How Linux Kernel Manages Memory: Allocation, OOM, and Recovery
Liangxu Linux
Liangxu Linux
Sep 26, 2021 · Operations

Master Linux Swap: When, How Much, and How to Optimize Performance

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.

Memory ManagementPerformance Tuningswap
0 likes · 15 min read
Master Linux Swap: When, How Much, and How to Optimize Performance
Programmer DD
Programmer DD
Sep 24, 2021 · Backend Development

Master JVM Startup Flags: Decode GC Logs and Optimize Memory

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.

GCJVMJava
0 likes · 10 min read
Master JVM Startup Flags: Decode GC Logs and Optimize Memory
Programmer DD
Programmer DD
Sep 17, 2021 · Backend Development

Avoid Out‑of‑Memory Errors: Properly Configure Spring Boot Async Thread Pool

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.

AsyncJavaMemory Management
0 likes · 11 min read
Avoid Out‑of‑Memory Errors: Properly Configure Spring Boot Async Thread Pool
WeDoctor Frontend Technology
WeDoctor Frontend Technology
Sep 15, 2021 · Fundamentals

Ace JavaScript Interviews: Master Variables, Types, Memory & Garbage Collection

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.

Garbage CollectionMemory ManagementType Checking
0 likes · 14 min read
Ace JavaScript Interviews: Master Variables, Types, Memory & Garbage Collection
Kuaishou Tech
Kuaishou Tech
Sep 10, 2021 · Mobile Development

Analyzing and Resolving a Main Thread ↔ JavaScriptCore Heap Collector Thread Deadlock on iOS 13

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.

DeadlockMemory ManagementRunLoop
0 likes · 17 min read
Analyzing and Resolving a Main Thread ↔ JavaScriptCore Heap Collector Thread Deadlock on iOS 13
Architect
Architect
Sep 9, 2021 · Fundamentals

Understanding JVM Memory Structure: Areas, Allocation, and Tuning

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.

Garbage CollectionJVMJava
0 likes · 16 min read
Understanding JVM Memory Structure: Areas, Allocation, and Tuning
WeChat Client Technology Team
WeChat Client Technology Team
Sep 8, 2021 · Mobile Development

Uncovering Hidden Android Thread Pitfalls: Memory Leaks, Monitoring, and Hook Solutions

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.

AndroidHookMemory Management
0 likes · 15 min read
Uncovering Hidden Android Thread Pitfalls: Memory Leaks, Monitoring, and Hook Solutions
Su San Talks Tech
Su San Talks Tech
Sep 7, 2021 · Fundamentals

Master Java Fundamentals: Essential Interview Topics and Core Concepts

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.

ExceptionsFundamentalsJVM
0 likes · 45 min read
Master Java Fundamentals: Essential Interview Topics and Core Concepts
Code Ape Tech Column
Code Ape Tech Column
Sep 1, 2021 · Fundamentals

Understanding Java Object Memory Layout with JOL

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.

JOLJVMJava
0 likes · 20 min read
Understanding Java Object Memory Layout with JOL
Kuaishou Frontend Engineering
Kuaishou Frontend Engineering
Aug 30, 2021 · Mobile Development

Why Does NSString Leak in Long‑Running Threads? Exploring ARC and AutoreleasePool

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.

ARCAutoreleasePoolMemory Management
0 likes · 23 min read
Why Does NSString Leak in Long‑Running Threads? Exploring ARC and AutoreleasePool
Xiaolei Talks DB
Xiaolei Talks DB
Aug 25, 2021 · Databases

Fixing Aerospike Cluster Outage: Network Glitches, Memory Limits, and Rebalancing

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.

AerospikeData RebalancingDatabase Troubleshooting
0 likes · 12 min read
Fixing Aerospike Cluster Outage: Network Glitches, Memory Limits, and Rebalancing
Architect's Tech Stack
Architect's Tech Stack
Aug 24, 2021 · Backend Development

Common JVM Startup Parameters and Their Usage

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.

Garbage CollectionJVMJava
0 likes · 11 min read
Common JVM Startup Parameters and Their Usage
Open Source Linux
Open Source Linux
Aug 21, 2021 · Operations

Linux Huge Pages vs Transparent Huge Pages: Benefits, Risks, and Disabling Guide

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.

Huge PagesLinuxMemory Management
0 likes · 9 min read
Linux Huge Pages vs Transparent Huge Pages: Benefits, Risks, and Disabling Guide
Tencent Music Tech Team
Tencent Music Tech Team
Aug 18, 2021 · Mobile Development

Flutter Memory Management and Leak Prevention in the MOO Music App

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.

FlutterMemory ManagementMobile Development
0 likes · 10 min read
Flutter Memory Management and Leak Prevention in the MOO Music App
Tencent Cloud Developer
Tencent Cloud Developer
Aug 5, 2021 · Fundamentals

Java vs Go: A Comparative Analysis of Garbage Collection Algorithms

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.

Garbage CollectionGenerational CollectionGo GC
0 likes · 14 min read
Java vs Go: A Comparative Analysis of Garbage Collection Algorithms
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Aug 5, 2021 · Backend Development

Deep Dive into JVM Tuning: Lessons from "Understanding the JVM" (3rd Edition)

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.

Garbage CollectionJDK toolsJVM
0 likes · 15 min read
Deep Dive into JVM Tuning: Lessons from "Understanding the JVM" (3rd Edition)
Tencent Cloud Developer
Tencent Cloud Developer
Aug 4, 2021 · Fundamentals

Golang Garbage Collection: Algorithms, Memory Management, and Evolution

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.

Concurrent MarkingGarbage CollectionGo
0 likes · 30 min read
Golang Garbage Collection: Algorithms, Memory Management, and Evolution
Open Source Linux
Open Source Linux
Aug 3, 2021 · Fundamentals

Master Linux Swap: When, How Much, and How to Optimize It

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.

LinuxMemory Managementswap
0 likes · 16 min read
Master Linux Swap: When, How Much, and How to Optimize It
Wukong Talks Architecture
Wukong Talks Architecture
Aug 3, 2021 · Databases

Redis Eviction Policies Explained

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.

CacheDatabasesMemory Management
0 likes · 3 min read
Redis Eviction Policies Explained
Tencent Cloud Developer
Tencent Cloud Developer
Aug 3, 2021 · Backend Development

Overview of Java Garbage Collection Algorithms and Memory Management

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.

Backend DevelopmentGC AlgorithmsGarbage Collection
0 likes · 16 min read
Overview of Java Garbage Collection Algorithms and Memory Management
Programmer DD
Programmer DD
Jul 28, 2021 · Fundamentals

Understanding Linux Virtual Memory: From Pages to Swap

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.

LinuxMemory ManagementPaging
0 likes · 13 min read
Understanding Linux Virtual Memory: From Pages to Swap
Wukong Talks Architecture
Wukong Talks Architecture
Jul 21, 2021 · Fundamentals

Understanding Redis Simple Dynamic Strings (SDS): Structure, Benefits, and Memory Management

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.

C stringsData StructuresMemory Management
0 likes · 11 min read
Understanding Redis Simple Dynamic Strings (SDS): Structure, Benefits, and Memory Management
Liulishuo Tech Team
Liulishuo Tech Team
Jul 14, 2021 · Game Development

Integrating Cocos Creator 3.0 for 3D Character Customization in an English Learning Community App

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.

3D Character CustomizationAsset Bundle ManagementCocos Creator 3.0
0 likes · 12 min read
Integrating Cocos Creator 3.0 for 3D Character Customization in an English Learning Community App
php Courses
php Courses
Jun 30, 2021 · Backend Development

Understanding PHP's zend_string Structure and Memory Management

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.

C languageMemory ManagementPHP
0 likes · 11 min read
Understanding PHP's zend_string Structure and Memory Management
ITPUB
ITPUB
Jun 27, 2021 · Fundamentals

How Multi‑Level Caching Boosts Performance and Avoids Common Pitfalls

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.

CPU cacheCache consistencyCaching
0 likes · 13 min read
How Multi‑Level Caching Boosts Performance and Avoids Common Pitfalls
21CTO
21CTO
Jun 19, 2021 · Fundamentals

Unlocking Linux: Inside the Kernel, Shell, Filesystem & Disk Management

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.

FilesystemLinuxMemory Management
0 likes · 33 min read
Unlocking Linux: Inside the Kernel, Shell, Filesystem & Disk Management
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Jun 17, 2021 · Game Development

How to Optimize Loading Speed, CPU, and Memory in Cocos Creator Games

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.

CPU optimizationCocos CreatorGame performance
0 likes · 17 min read
How to Optimize Loading Speed, CPU, and Memory in Cocos Creator Games
Top Architect
Top Architect
Jun 16, 2021 · Databases

Understanding MySQL Memory Management and When to Shard Tables

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.

Database PerformanceInnoDBLinux
0 likes · 17 min read
Understanding MySQL Memory Management and When to Shard Tables
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jun 11, 2021 · Fundamentals

Analysis of Linux mmap File Read Process and Page Fault Handling

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.

File CacheLinuxMemory Management
0 likes · 10 min read
Analysis of Linux mmap File Read Process and Page Fault Handling
Tencent Music Tech Team
Tencent Music Tech Team
Jun 10, 2021 · Mobile Development

iOS Crash Protection: Motivation, Process, and Implementation

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.

AOPMemory ManagementZombie Objects
0 likes · 11 min read
iOS Crash Protection: Motivation, Process, and Implementation
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 9, 2021 · Backend Development

Mastering Cache Optimization: From Distributed to CPU Cache and Beyond

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.

CPU cacheCachingMemory Management
0 likes · 13 min read
Mastering Cache Optimization: From Distributed to CPU Cache and Beyond
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 7, 2021 · Fundamentals

Understanding Java Garbage Collection: Reference Counting, Reachability Analysis, and Major GC Algorithms

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.

Garbage CollectionGenerational GCJava
0 likes · 7 min read
Understanding Java Garbage Collection: Reference Counting, Reachability Analysis, and Major GC Algorithms
DataFunTalk
DataFunTalk
Jun 4, 2021 · Fundamentals

Intel Optane Persistent Memory: Architecture, Programming Model, and Development Kit Overview

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.

Intel OptaneMemory ManagementNVM Programming
0 likes · 16 min read
Intel Optane Persistent Memory: Architecture, Programming Model, and Development Kit Overview
360 Smart Cloud
360 Smart Cloud
Jun 1, 2021 · Fundamentals

Physical Address Space Management and Memory Allocation in Linux (NUMA, Nodes, Zones, Pages, Slab, and Page Fault Handling)

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.

LinuxMemory ManagementPage Fault
0 likes · 17 min read
Physical Address Space Management and Memory Allocation in Linux (NUMA, Nodes, Zones, Pages, Slab, and Page Fault Handling)
Liangxu Linux
Liangxu Linux
May 31, 2021 · Fundamentals

Demystifying Linux Virtual Memory: Concepts, Paging, and Practical Commands

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.

LinuxMemory ManagementPaging
0 likes · 12 min read
Demystifying Linux Virtual Memory: Concepts, Paging, and Practical Commands
Liangxu Linux
Liangxu Linux
May 25, 2021 · Fundamentals

Why Virtual Memory Feels Like a Hotel: Understanding Linux Paging

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.

FundamentalsLinuxMemory Management
0 likes · 9 min read
Why Virtual Memory Feels Like a Hotel: Understanding Linux Paging
Liangxu Linux
Liangxu Linux
May 22, 2021 · Fundamentals

Unlocking Linux Memory Management: From CPU Access to CMA and Page Allocation

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.

LinuxMemory ManagementSlab Allocator
0 likes · 34 min read
Unlocking Linux Memory Management: From CPU Access to CMA and Page Allocation
Selected Java Interview Questions
Selected Java Interview Questions
May 5, 2021 · Databases

Understanding MySQL Temporary Tables, MEM_ROOT Memory Management, and Query Optimization

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.

GROUP BYMemory ManagementQuery Optimization
0 likes · 13 min read
Understanding MySQL Temporary Tables, MEM_ROOT Memory Management, and Query Optimization
DeWu Technology
DeWu Technology
Apr 29, 2021 · Backend Development

JVM Garbage Collection: CMS Principles and Tuning

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.

CMSGarbage CollectionJVM
0 likes · 18 min read
JVM Garbage Collection: CMS Principles and Tuning
Architect's Tech Stack
Architect's Tech Stack
Apr 29, 2021 · Databases

Analyzing Redis Latency Issues and How to Diagnose Them

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.

Database operationsLatencyMemory Management
0 likes · 18 min read
Analyzing Redis Latency Issues and How to Diagnose Them
Programmer DD
Programmer DD
Apr 27, 2021 · Fundamentals

Why Setting Unused Objects to null Can Actually Help Java GC – A Deep Dive

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.

Garbage CollectionJVMJava
0 likes · 10 min read
Why Setting Unused Objects to null Can Actually Help Java GC – A Deep Dive
macrozheng
macrozheng
Apr 26, 2021 · Backend Development

How Much Memory Does a Java Object Really Use?

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.

Backend DevelopmentJavaMemory Management
0 likes · 9 min read
How Much Memory Does a Java Object Really Use?
Top Architect
Top Architect
Apr 22, 2021 · Databases

Redis Lazy Free and Multi‑Threaded I/O: Architecture, Mechanisms, and Limitations

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.

Database PerformanceLazy FreeMemory Management
0 likes · 16 min read
Redis Lazy Free and Multi‑Threaded I/O: Architecture, Mechanisms, and Limitations
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 21, 2021 · Fundamentals

Understanding Java 8 Memory Structure: JVM Areas, Stack, Heap, and Native Memory

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.

JavaMemory ManagementNative Memory
0 likes · 13 min read
Understanding Java 8 Memory Structure: JVM Areas, Stack, Heap, and Native Memory
Miss Fresh Tech Team
Miss Fresh Tech Team
Apr 16, 2021 · Backend Development

Why G1GC? Understanding Soft Real‑Time and Pause‑Time Prediction in Java

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.

G1GCGarbage CollectionJVM
0 likes · 20 min read
Why G1GC? Understanding Soft Real‑Time and Pause‑Time Prediction in Java