The article explains that replacing Linux’s default 4 KB pages with 2 MB huge pages may reduce TLB misses but often degrades performance for typical micro‑service workloads, causing memory bloat, cache conflicts, and latency spikes, and demonstrates the issue with benchmark code and a step‑by‑step rollback guide.
The article explains why Java's immutable String class can waste memory when concatenated, introduces the mutable StringBuilder class introduced in J2SE 5.0, demonstrates its usage with code examples comparing memory behavior, shows its length and capacity methods, and illustrates practical operations such as reverse and conversion between String and StringBuilder.
This article explains the internal design of Java's ThreadLocalMap, covering its core Entry structure, hash table storage, linear probing for collision resolution, key operations (set, get, remove), memory‑leak scenarios, automatic cleanup mechanisms, and practical usage patterns such as thread‑context propagation and Android Looper.
This article records and analyzes how upgrading an application to JDK 11 changed the Direct Memory management strategy, causing a sharp increase in memory‑utilization alerts, and demonstrates step‑by‑step troubleshooting, code inspection, and JVM parameter tuning to restore normal memory usage.
This article recounts a production incident where Spring Boot services consumed excessive memory, explains how to diagnose the issue using jps and jmap, discusses default JVM heap settings, offers practical remediation steps, and also contains promotional material for AI community services and related offers.
Kotlin Native compiles Kotlin code to native binaries via an IR‑to‑LLVM pipeline, provides C/C++‑compatible memory layout, garbage‑collected runtime, and rich interop with C, C++, Objective‑C/Swift, while facing tooling and value‑type challenges that are being addressed through ongoing performance and language enhancements.
The article explains JVM runtime memory regions, heap allocation and generational layout, object reference types, major garbage‑collection algorithms and collectors, class‑loading phases, and provides practical tuning commands and case studies for optimizing GC pauses, preventing memory leaks, and diagnosing performance bottlenecks.
This article explains the Java class file format, including its magic number, version, constant pool, access flags, fields, methods, and attributes, and then details how the JVM loads, verifies, prepares, resolves, and initializes classes, manages object memory layout, and executes bytecode using a stack‑based interpreter.
This article documents a step‑by‑step investigation of a high TP99 caused by frequent Full GC in a Java service, describing the diagnostic mindset, tools used, GC trigger conditions, object promotion mechanisms, the impact of AdaptiveSizePolicy and Metaspace, and the concrete configuration and code changes that eliminated the issue.
This article explains the internal structure of Java class files—including magic numbers, versioning, constant pools, access flags, fields, methods, and attributes—illustrates bytecode generation with a sample class, and details the JVM's class loading, verification, preparation, resolution, initialization, memory allocation, object layout, and execution engine.
This article examines the MemoryLimitedLBQ and MemorySafeLBQ implementations, explains how they use memory‑limiting techniques to avoid Out‑Of‑Memory errors in unbounded LinkedBlockingQueue‑based thread pools, compares their designs, and shows practical code snippets for integrating them into Java projects.
This article explains how .NET's Microsoft.Extensions.ObjectPool framework can be used to reuse objects, customize pooling policies, integrate with dependency injection, and extend pooling to collections, StringBuilder, arrays and memory buffers, thereby minimizing garbage‑collection pressure and boosting application throughput.
This guide explains the difference between standard Huge Pages and Transparent Huge Pages in Linux, outlines the performance benefits and drawbacks of using Huge Pages, and provides step‑by‑step commands and GRUB configuration methods to safely disable Transparent Huge Pages on CentOS systems.
This article explains how Spark implements shuffle write and shuffle read, compares its high‑level and low‑level processes with Hadoop MapReduce, and details the internal data structures, memory‑disk trade‑offs, and configuration options that affect performance.
This article examines Spark's memory management and the shuffle process, identifies the components that consume the most memory during shuffle write and read, analyzes common OOM scenarios such as task concurrency and data skew, and offers configuration tips to prevent out‑of‑memory failures.
This article explores the fundamentals of building a high‑performance in‑memory cache, covering the relationship between caches and KV stores, various cache types, core data structures such as hash tables, lock strategies, rehash techniques, memory management, and network models, with practical examples and Go‑based concurrency designs.
The article explains how LinkedIn's Feed Mixer uses the SPR library and presents several Java performance optimizations—including careful loop traversal, pre‑sizing collections, lazy evaluation, pre‑compiling regexes, caching, and cautious use of String.intern—to dramatically cut memory consumption and latency.
