BestHub
Sign in
Tagged articles
950 articles
Page 8 of 10
Architect's Tech Stack
Architect's Tech Stack
Aug 18, 2020 · Databases

Understanding Redis Memory Limits and Eviction Policies

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.

LFULRUMemory Management
0 likes · 9 min read
Understanding Redis Memory Limits and Eviction Policies
Wukong Talks Architecture
Wukong Talks Architecture
Aug 7, 2020 · Fundamentals

JVM Interview Questions and Java Mind Map Resources

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.

Garbage CollectionJVMJava
0 likes · 8 min read
JVM Interview Questions and Java Mind Map Resources
Programmer DD
Programmer DD
Jul 26, 2020 · Databases

Mastering Redis Memory Limits and Eviction Policies: Config, LRU, LFU Explained

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.

LFULRUMemory Management
0 likes · 10 min read
Mastering Redis Memory Limits and Eviction Policies: Config, LRU, LFU Explained
MaGe Linux Operations
MaGe Linux Operations
Jul 16, 2020 · Databases

Master Redis Memory Limits and Eviction Policies: Config, LRU, LFU Explained

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.

LFULRUMemory Management
0 likes · 10 min read
Master Redis Memory Limits and Eviction Policies: Config, LRU, LFU Explained
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 10, 2020 · Fundamentals

Common Java OutOfMemoryError Types and Their Solutions

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.

JVMJavaMemory Management
0 likes · 20 min read
Common Java OutOfMemoryError Types and Their Solutions
Big Data Technology & Architecture
Big Data Technology & Architecture
Jul 5, 2020 · Big Data

Understanding Spark Memory Management: On‑heap, Off‑heap, and Unified Memory

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.

Big DataExecutorMemory Management
0 likes · 21 min read
Understanding Spark Memory Management: On‑heap, Off‑heap, and Unified Memory
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 5, 2020 · Fundamentals

Understanding JVM Runtime Data Areas and Memory Management

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.

Garbage CollectionJVMJava
0 likes · 42 min read
Understanding JVM Runtime Data Areas and Memory Management
Open Source Linux
Open Source Linux
Jul 3, 2020 · Fundamentals

Unlock Linux Memory: From Basics to Advanced Allocation Strategies

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.

Allocation AlgorithmsKernelLinux
0 likes · 23 min read
Unlock Linux Memory: From Basics to Advanced Allocation Strategies
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 30, 2020 · Fundamentals

Understanding Java Garbage Collection: Goals, Algorithms, and Timing

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.

GC AlgorithmsGarbage CollectionJVM
0 likes · 9 min read
Understanding Java Garbage Collection: Goals, Algorithms, and Timing
ITPUB
ITPUB
Jun 18, 2020 · Fundamentals

Mastering Linux Memory Management: From Address Space to Allocation Algorithms

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.

KernelLinuxMemory Management
0 likes · 20 min read
Mastering Linux Memory Management: From Address Space to Allocation Algorithms
Laravel Tech Community
Laravel Tech Community
Jun 16, 2020 · Mobile Development

Kuaishou’s APM Platform and Mobile Performance Optimization: Insights from Yang Kai

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.

APMKuaishouMemory Management
0 likes · 9 min read
Kuaishou’s APM Platform and Mobile Performance Optimization: Insights from Yang Kai
Python Programming Learning Circle
Python Programming Learning Circle
Jun 3, 2020 · Fundamentals

Understanding CPython's Memory Management (Python 2.7)

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.

CPythonGarbage CollectionMemory Management
0 likes · 23 min read
Understanding CPython's Memory Management (Python 2.7)
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 25, 2020 · Databases

Mastering Redis: Expiration Strategies, Memory Management, and Transactions

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.

ExpirationMemory ManagementThread Model
0 likes · 12 min read
Mastering Redis: Expiration Strategies, Memory Management, and Transactions
Selected Java Interview Questions
Selected Java Interview Questions
May 21, 2020 · Databases

Redis Memory Limits, Eviction Policies, and LRU/LFU Implementation

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.

ConfigurationJavaLFU
0 likes · 15 min read
Redis Memory Limits, Eviction Policies, and LRU/LFU Implementation
Java Captain
Java Captain
May 20, 2020 · Fundamentals

Why Setting Unused Objects to null May Not Help Java Garbage Collection

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.

Garbage CollectionJVMJava
0 likes · 8 min read
Why Setting Unused Objects to null May Not Help Java Garbage Collection
Open Source Linux
Open Source Linux
May 19, 2020 · Fundamentals

Essential Operating System Concepts Every Developer Should Know

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.

KernelMemory Managementcomputer architecture
0 likes · 45 min read
Essential Operating System Concepts Every Developer Should Know
macrozheng
macrozheng
Apr 22, 2020 · Databases

13 Proven Techniques to Supercharge Redis Performance

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.

Lazy FreeMemory ManagementPerformance Optimization
0 likes · 19 min read
13 Proven Techniques to Supercharge Redis Performance
Python Programming Learning Circle
Python Programming Learning Circle
Apr 21, 2020 · Fundamentals

9 Common Python Interview Questions and Answers

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.

Data StructuresGeneratorsMemory Management
0 likes · 11 min read
9 Common Python Interview Questions and Answers
Java Architect Essentials
Java Architect Essentials
Apr 17, 2020 · Fundamentals

Comprehensive Java JVM Interview Guide: Architecture, Memory, GC, Class Loading, and Optimization

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.

Garbage CollectionJVMMemory Management
0 likes · 31 min read
Comprehensive Java JVM Interview Guide: Architecture, Memory, GC, Class Loading, and Optimization
Sohu Tech Products
Sohu Tech Products
Apr 8, 2020 · Fundamentals

Design and Implementation of Go's Garbage Collector

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.

Garbage CollectionMemory Management
0 likes · 52 min read
Design and Implementation of Go's Garbage Collector
Java Backend Technology
Java Backend Technology
Apr 7, 2020 · Databases

How to Inspect and Clear Linux Buff/Cache and Optimize MySQL Joins

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.

Buffer CacheLinuxMemory Management
0 likes · 9 min read
How to Inspect and Clear Linux Buff/Cache and Optimize MySQL Joins
FunTester
FunTester
Apr 3, 2020 · Fundamentals

JVM Memory Model, GC Log Analysis, and Production Parameter Optimization

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.

Garbage CollectionJVMJava
0 likes · 10 min read
JVM Memory Model, GC Log Analysis, and Production Parameter Optimization
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 2, 2020 · Fundamentals

Fundamental Concepts of Operating Systems and Computer Architecture

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.

KernelMemory Managementcomputer architecture
0 likes · 25 min read
Fundamental Concepts of Operating Systems and Computer Architecture
FunTester
FunTester
Apr 1, 2020 · Backend Development

Mastering JVM Performance: 6 Essential Parameters and GC Tuning Tips

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.

Garbage CollectionHeap DumpJVM
0 likes · 9 min read
Mastering JVM Performance: 6 Essential Parameters and GC Tuning Tips
Senior Brother's Insights
Senior Brother's Insights
Mar 31, 2020 · Databases

Boost Redis Performance: 13 Proven Optimization Techniques

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.

Database TuningLazy FreeMemory Management
0 likes · 18 min read
Boost Redis Performance: 13 Proven Optimization Techniques
Python Programming Learning Circle
Python Programming Learning Circle
Mar 27, 2020 · Fundamentals

Understanding Python Memory Management: Reference Counting, Circular References, and Generational Garbage Collection

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.

Garbage CollectionGenerational GCMemory Management
0 likes · 8 min read
Understanding Python Memory Management: Reference Counting, Circular References, and Generational Garbage Collection
Architecture Digest
Architecture Digest
Mar 27, 2020 · Databases

Understanding Redis Memory Model: Objects, Allocation, and Internal Encoding

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.

Data StructuresMemory ManagementSDS
0 likes · 28 min read
Understanding Redis Memory Model: Objects, Allocation, and Internal Encoding
Architecture Digest
Architecture Digest
Mar 23, 2020 · Databases

Understanding Linux Buffer Cache and SQL Join Performance

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.

Buffer CacheDatabase PerformanceLinux
0 likes · 7 min read
Understanding Linux Buffer Cache and SQL Join Performance
Xianyu Technology
Xianyu Technology
Mar 19, 2020 · Mobile Development

FlutterBoost 2.0 Architecture Upgrade and iOS Performance Improvements

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.

FlutterFlutterBoostHybrid App
0 likes · 12 min read
FlutterBoost 2.0 Architecture Upgrade and iOS Performance Improvements
Big Data Technology Architecture
Big Data Technology Architecture
Mar 4, 2020 · Databases

HBase Memory‑Related Performance Tuning Guide

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.

CacheGarbage CollectionHBase
0 likes · 8 min read
HBase Memory‑Related Performance Tuning Guide
Liangxu Linux
Liangxu Linux
Mar 3, 2020 · Operations

Understanding Modern Operating Systems: From Hardware Basics to System Calls and Architecture

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.

Memory ManagementOS ArchitectureOperating System
0 likes · 68 min read
Understanding Modern Operating Systems: From Hardware Basics to System Calls and Architecture
macrozheng
macrozheng
Mar 3, 2020 · Fundamentals

Mastering Java Garbage Collection: Algorithms, Regions, and Tuning Tips

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.

Garbage CollectionJVMJava
0 likes · 31 min read
Mastering Java Garbage Collection: Algorithms, Regions, and Tuning Tips
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 2, 2020 · Databases

Redis Internals Explained: Data Structures, Memory Management & Use Cases

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.

Data StructuresIn-Memory DatabaseMemory Management
0 likes · 16 min read
Redis Internals Explained: Data Structures, Memory Management & Use Cases
Amap Tech
Amap Tech
Feb 27, 2020 · Mobile Development

Common Misunderstandings and Pitfalls in iOS Development – Foundation, UIKit, GCD and Best Practices

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.

GCDMemory ManagementObjective‑C
0 likes · 17 min read
Common Misunderstandings and Pitfalls in iOS Development – Foundation, UIKit, GCD and Best Practices
Python Programming Learning Circle
Python Programming Learning Circle
Feb 12, 2020 · Fundamentals

9 Common Python Interview Questions and Answers

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.

Data StructuresGeneratorsMemory Management
0 likes · 11 min read
9 Common Python Interview Questions and Answers
Programmer DD
Programmer DD
Feb 8, 2020 · Backend Development

Master Java Memory: Essential JVM Flags to Prevent OutOfMemory Errors

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.

JVMJavaMemory Management
0 likes · 3 min read
Master Java Memory: Essential JVM Flags to Prevent OutOfMemory Errors
Architecture Digest
Architecture Digest
Feb 4, 2020 · Databases

Comprehensive Guide to Redis: Usage, Performance, Data Types, Expiration Strategies, and Common Pitfalls

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.

Data StructuresMemory Managementcaching
0 likes · 12 min read
Comprehensive Guide to Redis: Usage, Performance, Data Types, Expiration Strategies, and Common Pitfalls
MaGe Linux Operations
MaGe Linux Operations
Feb 1, 2020 · Operations

Unraveling Linux Memory Usage: From free to slab and PageTables

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.

Memory ManagementPageTablesRSS
0 likes · 10 min read
Unraveling Linux Memory Usage: From free to slab and PageTables
Architect's Tech Stack
Architect's Tech Stack
Jan 18, 2020 · Fundamentals

JVM Memory Architecture: Overview, Heap, Metaspace, Stack, and More

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.

Garbage CollectionHeapJVM
0 likes · 16 min read
JVM Memory Architecture: Overview, Heap, Metaspace, Stack, and More
Tencent Cloud Developer
Tencent Cloud Developer
Jan 7, 2020 · Mobile Development

Hippy Cross-Platform Framework: Common Debugging Methods and Troubleshooting Cases

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.

AndroidDebuggingHippy
0 likes · 12 min read
Hippy Cross-Platform Framework: Common Debugging Methods and Troubleshooting Cases
ITPUB
ITPUB
Dec 15, 2019 · Fundamentals

Understanding Linux: Kernel, Memory, Processes, Filesystems and More

An extensive guide walks through Linux’s core components—kernel, memory and process management, VFS, device drivers, networking, shells, filesystem hierarchy, partitioning, mounting, and link types—detailing their structures, key commands, and practical examples for system administrators and developers.

FilesystemKernelLinux
0 likes · 35 min read
Understanding Linux: Kernel, Memory, Processes, Filesystems and More
Liangxu Linux
Liangxu Linux
Dec 12, 2019 · Fundamentals

Unlock Linux: A Deep Dive into Kernel, Memory, Processes, and Filesystems

This comprehensive guide explains the core components of a Linux system—including the kernel, memory management, process scheduling, device drivers, networking, shells, file‑system types, VFS architecture, mounting procedures, and link handling—providing clear examples, commands, and diagrams for each topic.

KernelLinksMemory Management
0 likes · 35 min read
Unlock Linux: A Deep Dive into Kernel, Memory, Processes, and Filesystems
Architecture Digest
Architecture Digest
Dec 11, 2019 · Fundamentals

Understanding Java String Concatenation, Constant Pool, and Bytecode Behavior

This article explains how Java handles String literals and concatenation, detailing the roles of the String constant pool, the effects of the '+' operator invoking StringBuilder.append, the placement of resulting strings in the heap versus the pool, and demonstrates these concepts through bytecode analysis and code examples.

Constant PoolJavaMemory Management
0 likes · 12 min read
Understanding Java String Concatenation, Constant Pool, and Bytecode Behavior
vivo Internet Technology
vivo Internet Technology
Dec 4, 2019 · Mobile Development

Analysis of Glide Lifecycle Management in Android

The article dissects Glide’s lifecycle management by tracing how Glide.with creates a singleton RequestManager via RequestManagerRetriever, caches headless RequestManagerFragments, forwards Activity/Fragment callbacks through ActivityFragmentLifecycle to pause, resume, or clear image requests, monitors network changes with a ConnectivityMonitor, and responds to memory pressure via component callbacks, thereby integrating Android component lifecycles, connectivity, and memory management into its image‑loading engine.

AndroidGlideImage Loading
0 likes · 18 min read
Analysis of Glide Lifecycle Management in Android
Selected Java Interview Questions
Selected Java Interview Questions
Nov 29, 2019 · Fundamentals

Understanding Object Liveness Determination in Java: Reference Counting and Reachability Analysis

The article explains how Java determines whether an object is alive using two main garbage‑collection algorithms—Reference Counting and Reachability Analysis—detailing their mechanisms, limitations such as circular references, the role of GC Roots, finalization, and method‑area reclamation, with illustrative code examples.

Garbage CollectionJVMJava
0 likes · 6 min read
Understanding Object Liveness Determination in Java: Reference Counting and Reachability Analysis
JD Retail Technology
JD Retail Technology
Nov 28, 2019 · Mobile Development

Understanding iOS Property Modifiers and Common Retain Cycle Scenarios

This article explains iOS property attribute categories, the memory‑related modifiers assign, weak, strong and copy, clarifies why assign can cause dangling pointers while weak does not, and describes typical retain‑cycle cases caused by blocks, NSTimer and delegate misuse along with practical solutions.

ARCMemory ManagementProperty Modifiers
0 likes · 7 min read
Understanding iOS Property Modifiers and Common Retain Cycle Scenarios
Big Data Technology & Architecture
Big Data Technology & Architecture
Nov 18, 2019 · Big Data

Understanding JVM Garbage Collection and Flink Memory Management

This article explains the fundamentals of JVM garbage collection, its generational algorithms and associated performance issues, and then details Apache Flink's memory management architecture, including MemorySegment, off‑heap buffers, serialization mechanisms, and type information for efficient big‑data processing.

Big DataFlinkGarbage Collection
0 likes · 7 min read
Understanding JVM Garbage Collection and Flink Memory Management
360 Tech Engineering
360 Tech Engineering
Nov 7, 2019 · Fundamentals

Understanding mmap: Concepts, Usage, and Typical Applications in Linux

This article explains the Linux mmap system call, covering virtual address space fundamentals, how mmap interacts with the page cache and inode structures, typical use‑cases such as shared memory and anonymous mappings, code examples, and special considerations like alignment, copy‑on‑write and memory swapping.

Copy-on-WriteLinuxMemory Management
0 likes · 9 min read
Understanding mmap: Concepts, Usage, and Typical Applications in Linux
Architecture Digest
Architecture Digest
Nov 7, 2019 · Fundamentals

How the JVM Determines Object Liveness and Its Garbage Collection Algorithms

This article explains the JVM memory model, how the JVM decides whether an object is alive using reference counting and reachability analysis, and describes the main garbage‑collection algorithms—including mark‑sweep, mark‑compact, copying, and generational collection—along with their advantages and drawbacks.

Garbage CollectionGenerational GCJVM
0 likes · 8 min read
How the JVM Determines Object Liveness and Its Garbage Collection Algorithms
Selected Java Interview Questions
Selected Java Interview Questions
Nov 4, 2019 · Databases

Redis Expiration Strategies and Memory Eviction Mechanisms

This article explains how Redis removes expired keys using periodic and lazy deletion, describes the slave expiration handling, details the asynchronous memory reclamation commands like UNLINK and FLUSHALL ASYNC, and outlines the various maxmemory eviction policies including LRU, LFU, and their implementations.

CacheExpirationLFU
0 likes · 13 min read
Redis Expiration Strategies and Memory Eviction Mechanisms
Programmer DD
Programmer DD
Nov 3, 2019 · Backend Development

Master Java GC: Understand Memory, Parameters, and Algorithms for Interviews

This article explains Java garbage collection fundamentals, detailing JVM memory layout, key -X and -XX parameters, the mechanisms of object survival, and the main GC algorithms—Mark‑Sweep, Copying, Mark‑Compact, and generational collection—providing clear diagrams and interview‑ready insights.

GC AlgorithmsGarbage CollectionInterview Preparation
0 likes · 9 min read
Master Java GC: Understand Memory, Parameters, and Algorithms for Interviews
Programmer DD
Programmer DD
Nov 2, 2019 · Backend Development

Master JVM Memory Structure: A Deep Dive into Java’s Runtime Architecture

This article explains the Java Virtual Machine’s memory layout, covering the five runtime regions—heap, method area, JVM stacks, native method stacks, and program counter—along with their purposes, thread‑visibility, garbage‑collection behavior, and common pitfalls such as OutOfMemoryError and StackOverflowError.

Garbage CollectionJVMJava
0 likes · 9 min read
Master JVM Memory Structure: A Deep Dive into Java’s Runtime Architecture
Senior Brother's Insights
Senior Brother's Insights
Oct 18, 2019 · Fundamentals

Unlocking Java: A Deep Dive into JVM Memory Architecture

This article provides a comprehensive introduction to the Java Virtual Machine’s memory architecture, detailing the five runtime areas—Program Counter, JVM Stack, Native Method Stack, Heap, and Method Area—their thread scope, memory allocation, garbage‑collection behavior, and common errors such as OutOfMemoryError and StackOverflowError.

Garbage CollectionJVMJava
0 likes · 9 min read
Unlocking Java: A Deep Dive into JVM Memory Architecture
High Availability Architecture
High Availability Architecture
Oct 17, 2019 · Fundamentals

Memory Allocation vs. Pooling: Performance Analysis Across Java, G1, ZGC, and C++

This article investigates whether to allocate new memory for each incoming message or to reuse memory from a pool, analyzing the impact on throughput and latency in batch and soft‑real‑time applications, and presenting extensive benchmark results for various garbage collectors, JVM options, and native C++ implementations.

JavaMemory ManagementPerformance Testing
0 likes · 31 min read
Memory Allocation vs. Pooling: Performance Analysis Across Java, G1, ZGC, and C++
Aikesheng Open Source Community
Aikesheng Open Source Community
Oct 10, 2019 · Databases

Source Code Analysis of DBLE Memory Management Module

This article provides a detailed analysis of DBLE's memory management module, explaining its structure, configuration parameters, allocation and recycling logic, and includes annotated source code snippets for classes such as DirectByteBufferPool and ByteBufferPage, illustrating how off‑heap and on‑heap memory are handled.

ByteBufferDBLEJava
0 likes · 13 min read
Source Code Analysis of DBLE Memory Management Module
21CTO
21CTO
Oct 9, 2019 · Fundamentals

Mastering OOP in C: Implement the State Pattern with Real Code

This article walks you through applying object‑oriented concepts in C by implementing the State design pattern, covering class simulation with structs, inheritance via macros, lifecycle management, polymorphism, and a complete client example that demonstrates state transitions for a water model.

CDesign PatternsMemory Management
0 likes · 13 min read
Mastering OOP in C: Implement the State Pattern with Real Code
Programmer DD
Programmer DD
Sep 27, 2019 · Fundamentals

Why Does a Java Process Use Far More Memory Than Its Heap?

This article explains why a Java process consumes far more virtual memory than the configured heap size by detailing JVM subsystems, off‑heap allocations, native libraries, thread stacks, and other factors that contribute to overall memory usage.

HeapJVMJava
0 likes · 7 min read
Why Does a Java Process Use Far More Memory Than Its Heap?
Programmer DD
Programmer DD
Sep 11, 2019 · Fundamentals

Why Java Strings Are Final and How Interning Affects Memory

This article explains the two ways to create Java strings, demonstrates how string literals are shared in the method area, shows the effect of the intern() method at runtime, and discusses why the String class is final, immutable, and thread‑safe.

JavaMemory ManagementString
0 likes · 8 min read
Why Java Strings Are Final and How Interning Affects Memory
MaGe Linux Operations
MaGe Linux Operations
Sep 7, 2019 · Fundamentals

How Linux Manages Memory: From Process Allocation to OOM and Cache

This article explores Linux kernel memory management, detailing process address space allocation, the behavior of the OOM killer, various memory mapping types (shared, private, anonymous), cache usage, manual and automatic memory reclamation, and related kernel parameters, providing practical insights and examples.

CacheKernelMemory Management
0 likes · 20 min read
How Linux Manages Memory: From Process Allocation to OOM and Cache
Ctrip Technology
Ctrip Technology
Aug 28, 2019 · Fundamentals

Java Memory Layout and Garbage Collection Principles

This article provides a comprehensive overview of the JVM runtime memory areas, explains how the JVM determines garbage objects, reviews major GC algorithms and collectors—including the latest ZGC—and offers practical code examples and command‑line instructions for reproducing various OutOfMemoryError scenarios.

G1Garbage CollectionJVM
0 likes · 29 min read
Java Memory Layout and Garbage Collection Principles
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 20, 2019 · Fundamentals

Why Java’s Garbage Collection Matters: Algorithms, Roots, and Memory Management

Java’s garbage collection, a critical yet often overlooked feature, encompasses various algorithms such as reference counting, reachability analysis, mark‑sweep, copying, and generational collection, each with distinct mechanisms, trade‑offs, and impacts on memory regions like Eden, Survivor, and Old spaces.

GC AlgorithmsGarbage CollectionJVM
0 likes · 15 min read
Why Java’s Garbage Collection Matters: Algorithms, Roots, and Memory Management
JavaEdge
JavaEdge
Aug 17, 2019 · Fundamentals

Why 640K Was Once “Enough” and How Modern Memory Management Solves It

From Bill Gates’s 640 KB claim to today’s multi‑gigabyte machines, this article explains how loaders map executable files, the evolution from segmentation to swapping and paging, and why virtual memory lets programs run with far less physical RAM despite performance trade‑offs.

Memory ManagementOperating SystemsPaging
0 likes · 12 min read
Why 640K Was Once “Enough” and How Modern Memory Management Solves It
Architect's Tech Stack
Architect's Tech Stack
Aug 1, 2019 · Fundamentals

Common Java OutOfMemoryError Types and Their Solutions

This article lists the most frequent Java OutOfMemoryError cases—including Java heap space, GC overhead limit exceeded, PermGen/Metaspace, native thread creation failures, array size limits, and direct buffer memory—explains their root causes, and provides practical troubleshooting steps and JVM tuning parameters to resolve them.

DebuggingJVMMemory Management
0 likes · 11 min read
Common Java OutOfMemoryError Types and Their Solutions
Node Underground
Node Underground
Jul 27, 2019 · Backend Development

Mastering Node.js Buffer: From Basics to Performance Optimization

This comprehensive guide explores Node.js Buffer fundamentals, binary data handling, stream integration, memory allocation mechanisms, practical usage scenarios, and performance benchmarks, providing developers with the knowledge to efficiently manage binary streams and boost application speed.

Memory ManagementNode.jsbinary data
0 likes · 21 min read
Mastering Node.js Buffer: From Basics to Performance Optimization
Programmer DD
Programmer DD
Jul 22, 2019 · Backend Development

Unlock Hidden JVM Memory: Track Native Allocations with NMT

This tutorial explains why Java applications often exceed their -Xmx limits, enumerates the main sources of native memory consumption in the JVM, and shows how to monitor and analyze these allocations using Native Memory Tracking (NMT) commands and flags.

JVMJavaMemory Management
0 likes · 13 min read
Unlock Hidden JVM Memory: Track Native Allocations with NMT
Java Backend Technology
Java Backend Technology
Jul 13, 2019 · Fundamentals

Why Java’s Garbage Collection Matters: From Roots to Generational Algorithms

This article explains Java garbage collection in depth, covering its definition, historical origins, reference‑counting and reachability algorithms, GC roots, memory regions such as Eden, Survivor and Old, and the main collection strategies like Mark‑Sweep, Copying, Mark‑Compact and Generational collection.

Garbage CollectionGenerational GCJVM
0 likes · 15 min read
Why Java’s Garbage Collection Matters: From Roots to Generational Algorithms
58 Tech
58 Tech
Jun 18, 2019 · Fundamentals

Understanding G1 Garbage Collector: Design, Algorithms, and Tuning Practices

This article explains the design principles, region-based architecture, object allocation strategies, Young and Mixed G1 GC phases, concurrent marking, three‑color marking, and practical tuning parameters for the G1 garbage collector in Java, illustrating concepts with code snippets and diagrams.

Garbage CollectionJVMJava
0 likes · 17 min read
Understanding G1 Garbage Collector: Design, Algorithms, and Tuning Practices
Big Data Technology & Architecture
Big Data Technology & Architecture
Jun 1, 2019 · Big Data

Understanding Spark Executor Memory Management: On‑Heap, Off‑Heap, and Unified Memory

This article explains Spark's executor memory architecture, covering on‑heap and off‑heap memory planning, static and unified memory managers, storage and execution memory allocation, RDD persistence, eviction policies, and shuffle memory usage, providing practical guidance for performance tuning.

Big DataExecutorMemory Management
0 likes · 23 min read
Understanding Spark Executor Memory Management: On‑Heap, Off‑Heap, and Unified Memory
Java Captain
Java Captain
May 27, 2019 · Fundamentals

Java Runtime Memory Areas, Object Creation, and Common Interview Questions

This article explains Java's runtime memory regions, including the program counter, stacks, heap, method area, constant pool, and direct memory, and details the HotSpot object creation process, memory layout, access mechanisms, as well as String and wrapper class behaviors, providing essential knowledge for Java interview preparation.

Interview PreparationJVMJava
0 likes · 19 min read
Java Runtime Memory Areas, Object Creation, and Common Interview Questions