BestHub
Sign in
Tagged articles
272 articles
Page 2 of 3
Alibaba Cloud Native
Alibaba Cloud Native
Dec 16, 2022 · Operations

Mastering Performance Testing: Tools, Techniques, and Real-World Case Studies

This comprehensive guide explains what performance testing (stress testing) is, why it matters, various test types, popular tools like ApacheBench, JMeter, LoadRunner and PTS, and provides detailed step-by-step methodologies and real-world case analyses for diagnosing memory, CPU, and latency issues in cloud‑native Java applications.

CPU optimizationJVM profilingload testing tools
0 likes · 24 min read
Mastering Performance Testing: Tools, Techniques, and Real-World Case Studies
Code Ape Tech Column
Code Ape Tech Column
Nov 16, 2022 · Operations

Using VisualVM for JVM Monitoring and Memory Leak Analysis

This article introduces VisualVM, a Java profiling tool bundled with the JDK, explains how to install and use its plugins for monitoring CPU, memory, threads, and garbage collection, and demonstrates step‑by‑step memory‑leak detection and remote Tomcat monitoring with code examples.

JVM MonitoringJava profilingVisualVM
0 likes · 7 min read
Using VisualVM for JVM Monitoring and Memory Leak Analysis
Dada Group Technology
Dada Group Technology
Oct 28, 2022 · Mobile Development

iOS Memory Management, OOM Causes, and Leak Monitoring Strategies

This article explains iOS memory architecture, the reasons behind Out‑of‑Memory (OOM) crashes, common sources of memory pressure, and practical approaches—including MLeaksFinder and FBRetainCycleDetector—to monitor, detect, and mitigate memory leaks and abnormal memory growth in iOS applications.

Memory ManagementMobile DevelopmentOOM
0 likes · 17 min read
iOS Memory Management, OOM Causes, and Leak Monitoring Strategies
Selected Java Interview Questions
Selected Java Interview Questions
Oct 6, 2022 · Backend Development

Understanding Java Inner Class Memory Leaks and How to Avoid Them

This article explains why non‑static inner classes in Java retain references to their outer class, causing memory leaks and eventual OutOfMemoryError, and demonstrates practical solutions such as avoiding references or converting the inner class to a static one, illustrated with code examples and debugging screenshots.

Garbage CollectionInner ClassStatic Class
0 likes · 7 min read
Understanding Java Inner Class Memory Leaks and How to Avoid Them
ByteFE
ByteFE
Sep 23, 2022 · Frontend Development

Curated Technical Articles: Productivity, Memory Leak Detection, Rust Challenges, Frontend Innovations, and More

This curated collection presents insights on engineering productivity, JavaScript memory leak detection with MemLab, Rust's top challenges, V8 execution, advanced frontend tools like Lath and Plasmo, Playwright component testing, senior engineering perspectives, and practical guides on proxy patterns and Babel plugins.

JavaScriptRustV8
0 likes · 7 min read
Curated Technical Articles: Productivity, Memory Leak Detection, Rust Challenges, Frontend Innovations, and More
Cognitive Technology Team
Cognitive Technology Team
Sep 12, 2022 · Fundamentals

Avoiding Memory Leaks with Java Double‑Brace Initialization and Anonymous Inner Classes

This article explains Java's double‑brace initialization trick, shows how it creates anonymous inner classes, demonstrates the resulting memory‑leak and OOM risks, especially with non‑static inner classes, and provides guidelines such as using static inner classes or weak references to avoid these problems.

Anonymous Inner ClassOOMdouble-brace-initialization
0 likes · 7 min read
Avoiding Memory Leaks with Java Double‑Brace Initialization and Anonymous Inner Classes
ELab Team
ELab Team
Aug 10, 2022 · Operations

How We Solved a Massive Memory Leak in a VSCode Extension Using llnode and heapdump

After releasing a new version of a VSCode extension, intermittent freezes were traced to a memory leak; the investigation used llnode and heapdump, tackled Electron version mismatches, extended DevTools parsing limits, and ultimately identified recursive socket callbacks as the root cause.

DevToolsPerformance debuggingVSCode
0 likes · 15 min read
How We Solved a Massive Memory Leak in a VSCode Extension Using llnode and heapdump
Ctrip Technology
Ctrip Technology
Jul 7, 2022 · Mobile Development

Performance Optimization Practices for a Flutter‑Based Hotel App at Ctrip

This article details how Ctrip's hotel team used Flutter to improve app performance over two years by monitoring FPS, TTI, memory, applying widget‑tree optimizations, lazy loading, frame rendering, service‑channel enhancements with Protobuf, and systematic memory‑leak detection and mitigation.

FlutterMobile DevelopmentProtobuf
0 likes · 22 min read
Performance Optimization Practices for a Flutter‑Based Hotel App at Ctrip
Java Backend Technology
Java Backend Technology
Jun 28, 2022 · Backend Development

Why ArrayList.subList Can Leak Memory, Loop Forever, and Crash Your Java App

This article explains how improper use of Java's ArrayList.subList can cause hidden memory leaks, infinite loops, ConcurrentModificationExceptions, and serialization failures in RPC frameworks, and provides concrete best‑practice solutions such as copying to a new list or using stream operations.

ArrayListConcurrentModificationExceptionSubList
0 likes · 9 min read
Why ArrayList.subList Can Leak Memory, Loop Forever, and Crash Your Java App
Programmer DD
Programmer DD
May 21, 2022 · Mobile Development

Mastering Android OOM: Thread, File, and Memory Leak Solutions

This technical guide explores Android out‑of‑memory crashes by classifying OOM into thread‑count, file‑descriptor, and heap‑memory issues, then details non‑intrusive thread and thread‑pool optimizations, file‑descriptor and I/O monitoring, image compression strategies, and both Java and native memory‑leak detection techniques.

AndroidOOMPerformance Monitoring
0 likes · 28 min read
Mastering Android OOM: Thread, File, and Memory Leak Solutions
Alibaba Terminal Technology
Alibaba Terminal Technology
May 12, 2022 · Frontend Development

How DingTalk Fixed FlutterEngine Crashes, Memory Leaks, and Deadlocks on Desktop

This article details the technical challenges DingTalk faced when integrating Flutter across macOS and Windows desktops, covering memory leaks, shutdown deadlocks, OpenGL crashes, rendering glitches, plugin registration wild‑pointer crashes, and white‑screen issues, and explains the root causes and concrete solutions applied to each problem.

CrashCross‑PlatformDesktop
0 likes · 12 min read
How DingTalk Fixed FlutterEngine Crashes, Memory Leaks, and Deadlocks on Desktop
Selected Java Interview Questions
Selected Java Interview Questions
May 5, 2022 · Backend Development

Understanding ThreadLocal in Java: Principles, Memory Leak Issues, and Proper Usage

This article explains Java's ThreadLocal mechanism, detailing its internal structure, including key methods like set, get, and remove, demonstrates how improper use can cause memory leaks, and provides best practices and examples for safe usage, including InheritableThreadLocal and real-world scenarios.

InheritableThreadLocalThreadLocalbest practices
0 likes · 18 min read
Understanding ThreadLocal in Java: Principles, Memory Leak Issues, and Proper Usage
IT Services Circle
IT Services Circle
Apr 26, 2022 · Backend Development

Typical Java Crash Scenarios with Sample Code

This article examines typical Java application failure scenarios—including heap OOM, memory leaks, CPU spikes, thread leaks, deadlocks, stack overflows, and blocked threads—providing concise code examples and practical diagnostic tips for root cause analysis.

CrashThreaddebugging
0 likes · 9 min read
Typical Java Crash Scenarios with Sample Code
Baidu Geek Talk
Baidu Geek Talk
Apr 7, 2022 · Mobile Development

Uncovering NSTimer Memory Leaks, Android Focus Mechanics, and Cookie Management

This article analyzes why NSTimer can cause memory leaks in iOS, presents two ways to break the retain cycle, then dives into Android's focus system—including acquisition, distribution, and clearing—and finally explains how WebView and native code handle cookies on Android.

Android FocusCookie ManagementMobile Development
0 likes · 16 min read
Uncovering NSTimer Memory Leaks, Android Focus Mechanics, and Cookie Management
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Apr 7, 2022 · Frontend Development

Understanding JavaScript Memory Management and Common Memory Leaks

This article explains JavaScript's memory lifecycle, defines memory leaks, enumerates typical leak patterns such as accidental globals, timers, closures and DOM references, and describes the underlying garbage‑collection strategies (mark‑and‑sweep and reference counting) together with practical mitigation techniques.

Garbage CollectionJavaScriptMemory Management
0 likes · 18 min read
Understanding JavaScript Memory Management and Common Memory Leaks
Efficient Ops
Efficient Ops
Mar 30, 2022 · Cloud Native

How to Fix Common Kubernetes Memory Leaks and Certificate Expiration Issues

This article walks through diagnosing and resolving two frequent Kubernetes problems—memory‑leak errors that cause "cannot allocate memory" or "no space left on device" messages, and expired cluster certificates—by checking cgroup stats, recompiling runc and kubelet, and renewing certificates with kubeadm for long‑term validity.

Kubernetescertificate-renewalkubeadm
0 likes · 12 min read
How to Fix Common Kubernetes Memory Leaks and Certificate Expiration Issues
Alibaba Terminal Technology
Alibaba Terminal Technology
Mar 7, 2022 · Backend Development

Why Node.js Hot Module Reload Can Leak Memory—and How to Avoid It

This article examines Node.js hot‑update mechanisms, explains how modules like clear‑module and decache can cause memory, resource, and versioning leaks, demonstrates real‑world examples with code, and offers guidance on when hot‑reloading is safe and how to mitigate its pitfalls.

Node.jsbackend-developmenthot-reload
0 likes · 17 min read
Why Node.js Hot Module Reload Can Leak Memory—and How to Avoid It
ByteDance Terminal Technology
ByteDance Terminal Technology
Mar 2, 2022 · Mobile Development

Analyzing and Optimizing Kapt Memory Consumption in Android Projects

This article examines the memory‑intensive behavior of Kotlin's Kapt annotation‑processing tool in large Android builds, explains its internal two‑step stub‑generation and Java‑apt workflow, analyzes OOM root causes with VisualVM, and presents a practical source‑filtering fix that dramatically reduces compile time and memory usage.

Annotation ProcessingKaptKotlin
0 likes · 16 min read
Analyzing and Optimizing Kapt Memory Consumption in Android Projects
DevOps
DevOps
Feb 10, 2022 · Operations

Eight Real-World Online Failure Cases and Their Resolution Strategies

The article presents eight authentic production incidents—including JVM Full GC, memory leaks, idempotency flaws, cache avalanches, disk‑I/O thread blocking, MySQL deadlocks, DNS hijacking, and bandwidth exhaustion—detailing their causes, diagnostics, and practical remediation steps for engineers.

Bandwidth ExhaustionDNS hijackingDatabase Deadlock
0 likes · 15 min read
Eight Real-World Online Failure Cases and Their Resolution Strategies
Programmer DD
Programmer DD
Jan 24, 2022 · Backend Development

How to Detect and Fix JVM CPU Spikes, Deadlocks, and Memory Leaks

Learn practical JVM tuning techniques by identifying high CPU usage, diagnosing deadlocks, and uncovering memory leaks using tools such as top, jstack, jps, jstat, and jmap, with step‑by‑step commands and code examples to help you optimize Java application performance.

CPUJVMProfiling
0 likes · 15 min read
How to Detect and Fix JVM CPU Spikes, Deadlocks, and Memory Leaks
21CTO
21CTO
Jan 18, 2022 · Fundamentals

Why Python 3.11 Is Twice as Fast as 3.10 – Inside the Shannon Plan

On January 18, 2022 the Python Software Foundation released Python 3.10, 3.9, and a preview of 3.11, detailing performance gains, Windows installer issues, and a critical Cython‑related memory leak fixed in the upcoming 3.10.3 release.

CPythonCythonVersion Release
0 likes · 5 min read
Why Python 3.11 Is Twice as Fast as 3.10 – Inside the Shannon Plan
Kuaishou Tech
Kuaishou Tech
Jan 14, 2022 · Operations

Analysis of Linux System Crash Caused by Memory Leak and the Role of min_free_kbytes

This article documents a system crash triggered by a memory‑leak in a network‑chip SDK, explains how low free memory and the kswapd process lead to deadlock, and shows how adjusting the kernel parameter min_free_kbytes can prevent the freeze while highlighting the importance of resource monitoring and tuning.

LinuxPerformance Monitoringkswapd
0 likes · 11 min read
Analysis of Linux System Crash Caused by Memory Leak and the Role of min_free_kbytes
Java Interview Crash Guide
Java Interview Crash Guide
Jan 14, 2022 · Fundamentals

How Does Java’s ThreadLocal Avoid Memory Leaks? Deep Dive into Its Design

This article explores Java's thread‑local storage, explaining why shared variables cause thread‑safety issues, how a proxy can hide object retrieval, the pitfalls of a naive Map‑based design that leads to memory leaks, and how the JDK's ThreadLocal uses weak references and ThreadLocalMap to safely manage per‑thread data.

ThreadLocaljavamemory leak
0 likes · 8 min read
How Does Java’s ThreadLocal Avoid Memory Leaks? Deep Dive into Its Design
Alibaba Terminal Technology
Alibaba Terminal Technology
Nov 17, 2021 · Mobile Development

Building a LeakCanary‑Style Memory Leak Detector for Flutter

This article analyzes why Flutter apps suffer from high memory usage, identifies BuildContext and State as primary leak sources, and proposes a comprehensive, automated detection tool inspired by Android LeakCanary that accurately and efficiently finds memory leaks in production Flutter applications.

BuildContextFlutterLeakCanary
0 likes · 16 min read
Building a LeakCanary‑Style Memory Leak Detector for Flutter
DeWu Technology
DeWu Technology
Nov 16, 2021 · Databases

Full-Chain Load Testing: Redis Large-Key and Memory Leak Issues and Solutions

Full‑chain load testing uncovered a Redis large‑key bottleneck that saturated bandwidth, a memory‑leak caused by repeatedly registering shutdown hooks, and persistently high JVM heap usage, leading to solutions of key sharding with local caching, registering hooks only once, and adjusting heap size, physical memory, and alert thresholds.

BackendLoad Testingmemory leak
0 likes · 7 min read
Full-Chain Load Testing: Redis Large-Key and Memory Leak Issues and Solutions
DeWu Technology
DeWu Technology
Nov 12, 2021 · Mobile Development

Detecting and Fixing iOS Memory Leaks with Object‑Graph Scanning

This article explains why iOS memory leaks become critical as apps grow, introduces five representative leak models, details a production‑ready object‑graph scanning solution with custom data structures and a non‑recursive DFS algorithm, and evaluates its performance impact and mitigation strategies.

DetectionalgorithmiOS
0 likes · 13 min read
Detecting and Fixing iOS Memory Leaks with Object‑Graph Scanning
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Nov 11, 2021 · Backend Development

Why Node.js Log Decryption Fails and How Multi‑Process/Thread Fixes It

This article examines a user‑side logging system where encrypted and compressed logs are uploaded, analyzes why decryption often stalls or fails, explores Node.js multi‑process and inter‑process communication methods, addresses sticky‑packet and exception handling issues, and presents solutions for performance, memory leaks, and reliable npm package publishing.

Log DecryptionNode.jsmemory leak
0 likes · 28 min read
Why Node.js Log Decryption Fails and How Multi‑Process/Thread Fixes It
Beike Product & Technology
Beike Product & Technology
Nov 5, 2021 · Mobile Development

Practical Guide to Detecting Circular References in iOS Applications

This article explains the fundamentals of iOS memory management, describes common memory‑leak scenarios such as circular references, introduces detection tools like MLeaksFinder and FBRetainCycleDetector, and provides concrete code examples and best‑practice techniques for preventing and fixing retain cycles in production apps.

FBRetainCycleDetectorMLeaksFindercircular reference
0 likes · 14 min read
Practical Guide to Detecting Circular References in iOS Applications
ByteDance Dali Intelligent Technology Team
ByteDance Dali Intelligent Technology Team
Nov 3, 2021 · Backend Development

How We Slashed Android Gradle Sync Time from 8 Minutes to 1.5 Minutes

Facing 8‑minute Gradle syncs, frequent GC‑over‑limit errors, and excessive memory usage, the team diagnosed severe memory leaks in Android build configurations, applied variantFilter filtering, tuned JVM arguments, and optimized daemon settings, ultimately reducing sync time to 1.5 minutes and cutting CI build time in half.

AndroidBuild OptimizationGradle
0 likes · 15 min read
How We Slashed Android Gradle Sync Time from 8 Minutes to 1.5 Minutes
Programmer DD
Programmer DD
Sep 26, 2021 · Backend Development

Mastering ThreadLocal in Java: When and How to Use It Safely

This article explains the two primary use cases of ThreadLocal in Java—providing each thread with its own exclusive object and sharing request‑scoped data across methods—while covering implementation details, memory‑leak risks, and best‑practice cleanup techniques.

ThreadLocalbackend-developmentconcurrency
0 likes · 10 min read
Mastering ThreadLocal in Java: When and How to Use It Safely
iQIYI Technical Product Team
iQIYI Technical Product Team
Sep 24, 2021 · Artificial Intelligence

Memory Leak Diagnosis and Fixes for TensorFlow Serving in iQIYI’s Deep Learning Platform

The iQIYI deep‑learning platform identified two TensorFlow Serving memory‑leak problems—a string‑accumulating executor map caused by unordered input maps and an uncontrolled gRPC thread surge under heavy load—submitted upstream patches that sort inputs and cap thread counts, eliminating OOM crashes and stabilizing production.

TensorFlow ServinggRPCmemory leak
0 likes · 10 min read
Memory Leak Diagnosis and Fixes for TensorFlow Serving in iQIYI’s Deep Learning Platform
vivo Internet Technology
vivo Internet Technology
Sep 22, 2021 · Backend Development

Investigation and Resolution of Netty ChannelOutboundBuffer Memory Leak in a Mobile Push System

In a high‑throughput mobile push service built on Netty, an off‑heap memory leak was traced to unchecked ChannelOutboundBuffer growth when half‑closed connections remained active but unwritable; fixing it by disabling autoRead on unwritable channels, configuring write‑buffer watermarks, and adding explicit isWritable() checks eliminated the crash and stabilized the system.

ChannelOutboundBufferNettyjava
0 likes · 10 min read
Investigation and Resolution of Netty ChannelOutboundBuffer Memory Leak in a Mobile Push System
Node Underground
Node Underground
Sep 11, 2021 · Backend Development

Why Node.js vm Triggers OOM in V8: Hidden Compilation Cache Pitfalls

This article explains how frequent use of Node.js's vm module can cause out‑of‑memory crashes in V8 due to an uncollected compilation cache, the role of the --always‑promote‑young‑mc flag, and practical work‑arounds for Node.js 12, 14 and 16.

Compilation CacheGarbage CollectionNode.js
0 likes · 16 min read
Why Node.js vm Triggers OOM in V8: Hidden Compilation Cache Pitfalls
Tencent Cloud Developer
Tencent Cloud Developer
Aug 30, 2021 · Backend Development

Troubleshooting Golang Memory Leaks: A Production Case Study

The case study walks through debugging a Go production service that regularly spiked to over 6 GB of resident memory, revealing that unbuffered channel leaks, mis‑configured HTTP client timeouts, and ultimately a cgo‑based image‑processing library spawning unmanaged threads caused the leaks, and outlines a systematic troubleshooting workflow.

GolangGoroutinecgo
0 likes · 12 min read
Troubleshooting Golang Memory Leaks: A Production Case Study
Tencent Music Tech Team
Tencent Music Tech Team
Aug 19, 2021 · Mobile Development

Practical Investigation of Memory Leaks in Flutter – Image Instance Case Study

The article describes how the MOO app team used Flutter's Dart VM Observatory and Allocation Profile tools to detect and fix an image memory leak caused by a custom painter not deregistering an ImageStreamListener, demonstrating step-by-step snapshot comparison, reference‑chain analysis, and the resulting memory stabilization after code fix.

Allocation ProfileFlutterImage
0 likes · 9 min read
Practical Investigation of Memory Leaks in Flutter – Image Instance Case Study
Amap Tech
Amap Tech
Aug 18, 2021 · Frontend Development

Investigating and Preventing Memory Leaks in Web Pages Using Chrome DevTools

The article shows how to detect and stop memory leaks in web pages with Chrome DevTools—using heap snapshots, allocation‑instrumentation timelines, and the Performance panel—to expose leaks from globals, closures, detached DOM nodes, excess elements, or console logging, and offers practical coding guidelines to avoid them.

Chrome DevToolsmemory leakperformance
0 likes · 20 min read
Investigating and Preventing Memory Leaks in Web Pages Using Chrome DevTools
ByteFE
ByteFE
Aug 6, 2021 · Backend Development

Curated Collection of Technical Articles on Node.js, Architecture, Cross‑Platform Solutions, VSCode, and Tooling

This article compiles a series of curated technical write‑ups covering enterprise Node.js foundations, type‑safe Node.js frameworks, complex system architecture, cross‑platform solution analysis, front‑end engineering efficiency, collaborative online document design, VSCode performance, decorator usage, CSS static analysis, and JavaScript memory‑leak prevention.

Node.jsmemory leakstatic analysis
0 likes · 4 min read
Curated Collection of Technical Articles on Node.js, Architecture, Cross‑Platform Solutions, VSCode, and Tooling
Code Ape Tech Column
Code Ape Tech Column
Aug 3, 2021 · Backend Development

Why Does Java Leak Memory? Deep Dive into Causes and Prevention

This article explains what memory leaks are in Java, compares them with C++ leaks, describes the garbage collection mechanism, lists common leak sources such as static collections, listeners, and singletons, and provides practical guidelines and tools to detect and prevent them.

Garbage Collectionbest practicesjava
0 likes · 18 min read
Why Does Java Leak Memory? Deep Dive into Causes and Prevention
Java Architect Essentials
Java Architect Essentials
Jul 25, 2021 · Backend Development

How I Cut Full GC Frequency by 80%: A JVM Tuning Case Study

Over a month of systematic JVM tuning reduced Full GC from 40 times per day to once every ten days and halved Young GC duration by adjusting heap sizes, survivor ratios, and metaspace settings while investigating and fixing a memory leak caused by an anonymous inner class listener.

BackendGarbage CollectionJVM
0 likes · 10 min read
How I Cut Full GC Frequency by 80%: A JVM Tuning Case Study
Programmer DD
Programmer DD
Jul 23, 2021 · Fundamentals

Why Overriding hashCode Matters: Prevent Memory Leaks and OOM

This article explores the distinction between OutOfMemory errors and memory leaks in Java, examines how improper use of static fields, unclosed streams, incorrect equals/hashCode implementations, and ThreadLocal can cause leaks, and provides practical solutions and tools such as JVisualVM to detect and prevent these issues.

JVMOutOfMemoryThreadLocal
0 likes · 16 min read
Why Overriding hashCode Matters: Prevent Memory Leaks and OOM
Java Interview Crash Guide
Java Interview Crash Guide
Jul 9, 2021 · Operations

Mastering JVisualVM: Detect and Analyze Java Memory Leaks & Remote Tomcat Monitoring

JVisualVM, bundled with JDK, provides a visual interface to monitor JVM threads, memory, and CPU usage, allowing installation of plugins for GC, thread, and memory analysis, demonstrating how to simulate memory leaks, capture heap dumps, compare snapshots, trace object references, and set up remote Tomcat monitoring via JMX.

JVisualVMProfilingTomcat
0 likes · 8 min read
Mastering JVisualVM: Detect and Analyze Java Memory Leaks & Remote Tomcat Monitoring
Java Backend Technology
Java Backend Technology
May 29, 2021 · Backend Development

Avoid Hidden ThreadLocal Pitfalls: Memory Leaks, Context Loss in Thread Pools & Parallel Streams

This article explains three common ThreadLocal misuse traps—memory leaks caused by weak‑referenced keys, loss of thread‑local context in thread‑pool workers, and context disappearance in parallel streams—provides detailed code examples, and offers practical guidelines to prevent them in Java backend applications.

Parallel StreamThreadLocalconcurrency
0 likes · 9 min read
Avoid Hidden ThreadLocal Pitfalls: Memory Leaks, Context Loss in Thread Pools & Parallel Streams
Programmer DD
Programmer DD
May 27, 2021 · Operations

How We Cut Full GC Frequency from 40×/Day to Once Every 10 Days

Over a month of JVM tuning, the author reduced Full GC from more than 40 times per day to once every ten days and halved Young GC duration by adjusting heap sizes, fixing memory leaks, and tuning metaspace, ultimately improving server throughput and stability.

Full GCGarbage CollectionJVM
0 likes · 12 min read
How We Cut Full GC Frequency from 40×/Day to Once Every 10 Days
Programmer DD
Programmer DD
May 23, 2021 · Operations

How I Cut Full GC Frequency from 40 to 1 in 10 Days: A JVM Tuning Journey

Over a month of systematic investigation, the author reduced Full GC occurrences on a 2‑core, 4 GB Java server cluster from 40 times a day to roughly once every ten days by adjusting heap settings, fixing a memory‑leak caused by an anonymous listener, and tuning Metaspace and CMS thresholds, ultimately achieving stable performance and lower latency.

Garbage CollectionJVMjava
0 likes · 11 min read
How I Cut Full GC Frequency from 40 to 1 in 10 Days: A JVM Tuning Journey
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 19, 2021 · Backend Development

Understanding ThreadLocal in Java: Concepts, Memory‑Leak Risks, Source‑Code Walkthrough, and Best Practices

This article explains what ThreadLocal is, demonstrates how it works with and without it, analyses its source code, discusses potential memory‑leak issues, and provides best‑practice guidelines and a Spring‑Boot example for safe usage in multithreaded Java applications.

Spring BootThreadLocalbest practices
0 likes · 12 min read
Understanding ThreadLocal in Java: Concepts, Memory‑Leak Risks, Source‑Code Walkthrough, and Best Practices
Tencent Music Tech Team
Tencent Music Tech Team
Apr 23, 2021 · Mobile Development

Native Memory Analysis and Optimization in Android K歌 Application

The article details a thorough investigation of native‑memory crashes in the K歌 Android app, describing how memory usage was profiled, comparing three analysis tools, building a custom loli_profiler‑based hook to track malloc/free and bitmap allocations, exposing leaks, and outlining fixes and future optimization plans.

AndroidBitmapHooking
0 likes · 28 min read
Native Memory Analysis and Optimization in Android K歌 Application
ByteFE
ByteFE
Apr 14, 2021 · Frontend Development

Understanding JavaScript Memory Leaks and Garbage Collection

This article explains JavaScript memory leaks, covering their definition, how JS manages stack and heap memory, automatic garbage collection, Chrome DevTools profiling techniques, and common leak patterns such as improper closures, global variables, detached DOM nodes, console logging, and forgotten timers, with detection and mitigation strategies.

Chrome DevToolsGarbage CollectionJavaScript
0 likes · 17 min read
Understanding JavaScript Memory Leaks and Garbage Collection
Java Backend Technology
Java Backend Technology
Mar 28, 2021 · Backend Development

Hidden Java Memory Leaks: 8 Common Pitfalls and How to Fix Them

This article explains eight typical Java memory‑leak scenarios—including unclosed resources, missing equals/hashCode, non‑static inner classes, overridden finalize, String.intern misuse, ThreadLocal traps, and static variables in web containers—provides code examples for each, and offers practical mitigation strategies.

Garbage CollectionThreadLocalTomcat
0 likes · 11 min read
Hidden Java Memory Leaks: 8 Common Pitfalls and How to Fix Them
vivo Internet Technology
vivo Internet Technology
Mar 24, 2021 · Mobile Development

How LeakCanary 2.0 Detects Android Memory Leaks: Architecture and Hprof Parsing Explained

This article provides a detailed technical analysis of LeakCanary 2.0, covering its Kotlin‑based integration, the new self‑implemented Hprof parser, detection workflow, core classes such as AppWatcher and ObjectWatcher, graph indexing, and the algorithm used to locate the shortest GC‑root leak path.

AndroidHeap AnalysisHprof
0 likes · 15 min read
How LeakCanary 2.0 Detects Android Memory Leaks: Architecture and Hprof Parsing Explained
360 Tech Engineering
360 Tech Engineering
Mar 22, 2021 · Databases

Analyzing and Optimizing High Memory and Disk I/O Consumption of InfluxDB 1.8 on a Production Server

This article investigates why an InfluxDB 1.8 instance on a 32‑core, 64 GB server consumes over 58 GB of resident memory and generates heavy disk I/O, examines Go runtime memory accounting, uses system tools such as top, pmap, pprof and iostat for diagnosis, and presents configuration and runtime tweaks that reduce memory pressure and I/O load.

InfluxDBLinuxgo runtime
0 likes · 13 min read
Analyzing and Optimizing High Memory and Disk I/O Consumption of InfluxDB 1.8 on a Production Server
360 Smart Cloud
360 Smart Cloud
Mar 19, 2021 · Databases

Root Cause Analysis and Performance Optimization of InfluxDB 1.8 Memory and Disk I/O on a Production Server

The article investigates why an InfluxDB 1.8 instance on a 32‑core, 64 GB production server consumes over 95% memory and generates heavy disk I/O, analyzes runtime statistics, pprof data, and Go memory‑release behavior, and presents configuration and runtime tweaks that reduce memory usage to ~55% and I/O load to acceptable levels.

Database OptimizationDisk I/OInfluxDB
0 likes · 12 min read
Root Cause Analysis and Performance Optimization of InfluxDB 1.8 Memory and Disk I/O on a Production Server
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Mar 17, 2021 · Backend Development

Analyzing Node.js .heapsnapshot Files and Using heapquery for Memory‑Leak Investigation

The article shows how to generate a Node.js V8 heap snapshot with v8.getHeapSnapshot, explains the JSON‑like .heapsnapshot structure of nodes, edges, and strings, and demonstrates using the heapquery tool to import the data into SQLite for SQL queries that locate and trace memory‑leaking objects such as a HugeObj instance.

HeapSnapshotNode.jsV8
0 likes · 17 min read
Analyzing Node.js .heapsnapshot Files and Using heapquery for Memory‑Leak Investigation
Architect's Tech Stack
Architect's Tech Stack
Feb 20, 2021 · Backend Development

Root Cause Analysis of High Native Memory Usage in a Spring Boot Application

After migrating a project to the MDP framework based on Spring Boot, the system repeatedly reported excessive swap usage; the investigation revealed that native memory allocated by the Spring Boot classloader’s Reflections scanning and InflaterInputStream caused 700 MB–800 MB of off‑heap memory to remain unreleased, which was eventually resolved by limiting the scan path and updating Spring Boot.

Native MemoryPerformance debuggingSpring Boot
0 likes · 12 min read
Root Cause Analysis of High Native Memory Usage in a Spring Boot Application
Selected Java Interview Questions
Selected Java Interview Questions
Feb 8, 2021 · Fundamentals

Understanding Memory Leaks and Memory Overflow: Causes, Types, and Solutions

Memory leaks, caused by unreleased dynamic allocations, can accumulate and lead to memory overflow, severely degrading performance or crashing applications; this article explains leak definitions, causes, classifications (persistent, intermittent, one‑time, implicit), overflow reasons, and practical mitigation steps such as proper allocation, deallocation, and JVM tuning.

JVMResource Managementdynamic allocation
0 likes · 9 min read
Understanding Memory Leaks and Memory Overflow: Causes, Types, and Solutions
dbaplus Community
dbaplus Community
Jan 21, 2021 · Operations

7 Real‑World Production Failures and How to Diagnose Them Quickly

The article shares eight concrete production incidents—from JVM Full GC spikes and memory leaks to cache avalanches, deadlocks, DNS hijacking and bandwidth exhaustion—detailing their root causes, step‑by‑step diagnostics, code snippets, monitoring tricks and practical remediation measures for engineers.

Database DeadlockFull GCJVM
0 likes · 18 min read
7 Real‑World Production Failures and How to Diagnose Them Quickly
Programmer DD
Programmer DD
Sep 29, 2020 · Backend Development

How ThreadLocal Works Internally and Why It Can Cause Memory Leaks

This article explains the internal mechanism of Java's ThreadLocal, how each thread maintains its own isolated map, why weak references are used for keys, and how improper cleanup in thread‑pool environments can lead to subtle memory‑leak problems.

ThreadLocalbackend-developmentjava
0 likes · 6 min read
How ThreadLocal Works Internally and Why It Can Cause Memory Leaks
Xianyu Technology
Xianyu Technology
Sep 23, 2020 · Mobile Development

Detecting Memory Leaks in Flutter via Rendering Tree Analysis

By tracking the discrepancy between the number of EngineLayer objects actually rendered each frame and the total EngineLayer instances retained in native memory, developers can detect and pinpoint Flutter memory leaks caused by lingering Dart references, using SceneBuilder monitoring and WeakPersistentHandle inspection.

DARTFlutterGarbage Collection
0 likes · 10 min read
Detecting Memory Leaks in Flutter via Rendering Tree Analysis
Architect
Architect
Aug 30, 2020 · Backend Development

Root Cause Analysis of Excessive Swap Memory Usage in a Spring Boot Application

The article details a step‑by‑step investigation of abnormal swap memory consumption in a Spring Boot project, revealing that native memory allocated by the Inflater during JAR scanning was not released promptly, leading to apparent memory leaks that were ultimately resolved by configuring package scanning and updating Spring Boot.

Native MemoryPerformance debuggingSpring Boot
0 likes · 12 min read
Root Cause Analysis of Excessive Swap Memory Usage in a Spring Boot Application
dbaplus Community
dbaplus Community
Aug 11, 2020 · Operations

7 Real-World Production Failures and Fast Diagnosis Techniques

The article shares seven authentic production incident cases—from JVM Full GC spikes and memory leaks to cache avalanches, disk I/O blocks, database deadlocks, DNS hijacking, and bandwidth exhaustion—detailing root causes, step‑by‑step troubleshooting methods, code snippets, and practical mitigation strategies for engineers.

DNS hijackingDatabase DeadlockJVM
0 likes · 17 min read
7 Real-World Production Failures and Fast Diagnosis Techniques
macrozheng
macrozheng
Aug 6, 2020 · Backend Development

When ‘No‑Comment’ Java Code Triggers a Memory Leak – A ConcurrentHashMap Study

A newly hired architect boasts high‑concurrency expertise but writes un‑commented Java code that misuses ConcurrentHashMap, leading to memory leaks; the ensuing investigation reveals missing equals/hashCode implementations, race conditions in a visit method, and a debate between synchronized blocks and putIfAbsent for safe updates.

ConcurrentHashMapSynchronizationbackend-development
0 likes · 8 min read
When ‘No‑Comment’ Java Code Triggers a Memory Leak – A ConcurrentHashMap Study
Programmer DD
Programmer DD
Aug 6, 2020 · Fundamentals

Why Overriding equals Without hashCode Can Cause Memory Leaks in Java

This article explores the distinction between OutOfMemory errors and memory leaks in Java, explains how improper use of static fields, unclosed streams, incorrect equals/hashCode implementations, and ThreadLocal can lead to leaks, and provides practical solutions and tools such as JVisualVM to detect and prevent them.

JVMOutOfMemoryThreadLocal
0 likes · 14 min read
Why Overriding equals Without hashCode Can Cause Memory Leaks in Java
Java Backend Technology
Java Backend Technology
Jul 31, 2020 · Backend Development

How a “No‑Comment” Java Code Caused a Massive Memory Leak – Lessons on ConcurrentHashMap

A senior architect’s over‑confident, un‑commented Java code using ConcurrentHashMap triggered a severe memory leak, revealing pitfalls in hashCode/equals implementation, non‑atomic map updates, and the trade‑offs between synchronized blocks and putIfAbsent for high‑concurrency monitoring.

ConcurrentHashMapSynchronizationjava
0 likes · 8 min read
How a “No‑Comment” Java Code Caused a Massive Memory Leak – Lessons on ConcurrentHashMap
Java Backend Technology
Java Backend Technology
Jul 7, 2020 · Backend Development

Why My Spring Boot App Swallowed 7 GB RAM: Uncovering Native Memory Leaks

After migrating a project to the MDP framework based on Spring Boot, the author observed excessive swap usage and physical memory consumption of 7 GB despite a 4 GB heap limit, and through a series of JVM, system, and native‑code diagnostics identified Spring Boot’s ZipInflaterInputStream native‑memory leak caused by unchecked package scanning.

JVMNative MemorySpring Boot
0 likes · 12 min read
Why My Spring Boot App Swallowed 7 GB RAM: Uncovering Native Memory Leaks
Architecture Digest
Architecture Digest
Jul 5, 2020 · Backend Development

Diagnosing Excessive Off‑Heap Memory Usage in a Spring Boot Application

The article details a step‑by‑step investigation of why a Spring Boot service migrated to the MDP framework consumed far more physical memory than its 4 GB heap, revealing native‑code allocations, memory‑pool behavior of glibc and tcmalloc, and how limiting MCC scan paths or upgrading Spring Boot resolves the off‑heap leak.

Native MemoryOff-Heap MemoryPerformance debugging
0 likes · 11 min read
Diagnosing Excessive Off‑Heap Memory Usage in a Spring Boot Application
Programmer DD
Programmer DD
Jul 5, 2020 · Backend Development

Why Did My Spring Boot Service Consume 7 GB? Uncovering Native Memory Leaks

The article details a step‑by‑step investigation of a Spring Boot application that unexpectedly used 7 GB of physical memory despite a 4 GB heap limit, revealing how native memory allocations, the Inflater class, and glibc memory pools caused off‑heap leaks and how proper configuration and library updates resolved the issue.

Native MemorySpring Bootdebugging
0 likes · 13 min read
Why Did My Spring Boot Service Consume 7 GB? Uncovering Native Memory Leaks
Programmer DD
Programmer DD
Jun 29, 2020 · Backend Development

Why Spring Beans Aren’t Thread‑Safe and How ThreadLocal Solves It

This article explains that Spring does not guarantee thread safety for its beans, describes the various bean scopes, clarifies why stateless singleton beans are safe, and shows how ThreadLocal works—including its implementation, usage, and potential memory‑leak pitfalls—so developers can write correct concurrent code.

ThreadLocalconcurrencyjava
0 likes · 17 min read
Why Spring Beans Aren’t Thread‑Safe and How ThreadLocal Solves It
Senior Brother's Insights
Senior Brother's Insights
Jun 3, 2020 · Backend Development

How We Traced and Fixed Excessive Native Memory Usage After Migrating to Spring Boot

After moving a project to Spring Boot, the system reported unusually high swap usage despite a 4 GB heap, prompting a detailed investigation using JVM native‑memory tracking, pmap, gperftools, strace, and GDB, which ultimately identified Spring Boot’s JAR scanning and glibc memory arenas as the root causes and led to a configuration fix and an upgrade to resolve the off‑heap memory leak.

JVMLinuxNative Memory
0 likes · 11 min read
How We Traced and Fixed Excessive Native Memory Usage After Migrating to Spring Boot
Liangxu Linux
Liangxu Linux
May 31, 2020 · Fundamentals

Detecting Memory Leaks and Errors with AddressSanitizer (ASan)

This guide explains how to use GCC's built‑in AddressSanitizer to detect memory leaks, heap/stack/global buffer overflows, use‑after‑free, and initialization‑order bugs, providing sample code, compilation flags, and example outputs for each error type.

AddressSanitizerC++ debuggingUse-After-Free
0 likes · 18 min read
Detecting Memory Leaks and Errors with AddressSanitizer (ASan)