BestHub
Sign in
Tagged articles

memory-leak

281 articles · Page 2 of 3
Baidu Geek Talk
Baidu Geek Talk
May 16, 2023 · Mobile Development

Common Memory Leak Issues in Android and iOS Development

The article outlines frequent memory‑leak pitfalls in Android (such as anonymous inner classes, static singletons, unregistered listeners, unclosed streams, and lingering animations) and iOS (including block retain cycles, strong delegate references, NSTimer retention, unmanaged CoreFoundation objects, and dispatch_after), and provides concrete code‑level remedies to prevent out‑of‑memory crashes.

AndroidMobile Developmentbest practices
0 likes · 13 min read
Common Memory Leak Issues in Android and iOS Development
Programmer DD
Programmer DD
Apr 25, 2023 · Artificial Intelligence

Why a Single QR Code Crashes WeChat: Inside the Memory Leak Bug

An unusual QR code triggers a memory‑leak in WeChat’s OCR engine, causing the app to crash on both mobile and desktop; the article explains the underlying null‑pointer exception, shows how the malformed “abnormal QR code” corrupts libqbar.so, and provides Python code to reproduce the bug using OpenCV’s open‑source QR engine.

CrashPythonQR code
0 likes · 9 min read
Why a Single QR Code Crashes WeChat: Inside the Memory Leak Bug
JD Cloud Developers
JD Cloud Developers
Mar 22, 2023 · Frontend Development

How to Detect and Prevent JavaScript Memory Leaks in Frontend Apps

Understanding JavaScript memory management, this guide explains the fundamentals of memory allocation, usage, and garbage collection, outlines common leak scenarios such as global variables, timers, event listeners, and data structures, and provides practical techniques and tools for detecting, diagnosing, and fixing memory leaks in web applications.

JavaScriptPerformancefrontend
0 likes · 15 min read
How to Detect and Prevent JavaScript Memory Leaks in Frontend Apps
IT Services Circle
IT Services Circle
Jan 13, 2023 · Frontend Development

Why console.log Can Cause Memory Leaks in Frontend JavaScript and How to Diagnose Them

This article explains how using console.log in frontend JavaScript can create memory leaks by retaining object references, demonstrates the issue with Chrome Performance and Memory tools, compares it with code without console.log, and offers alternative debugging techniques such as debugger, logpoints, and breakpoints.

JavaScriptPerformanceconsole.log
0 likes · 7 min read
Why console.log Can Cause Memory Leaks in Frontend JavaScript and How to Diagnose Them
DeWu Technology
DeWu Technology
Jan 4, 2023 · Backend Development

Diagnosing and Resolving Go Memory Leak with pprof and Prometheus

The article explains how a sudden Go service memory‑usage alert was traced with go tool pprof to a massive allocation in the quantile.newStream function, uncovered a Prometheus metric‑label explosion caused by the START_POINT label, and resolved the leak by disabling that label, while also reviewing typical Go memory‑leak patterns.

GoPrometheusbackend
0 likes · 15 min read
Diagnosing and Resolving Go Memory Leak with pprof and Prometheus
NetEase Yanxuan Technology Product Team
NetEase Yanxuan Technology Product Team
Dec 26, 2022 · Backend Development

Analysis and Resolution of Full GC Issues in Inventory Center Online Business

The article describes analysis and resolution of full GC issues in the inventory center online business, detailing incident review, emergency measures like memory expansion and restart, root‑cause discovery of a memory leak caused by loading massive procurement out‑stock data and blocked threads, and mitigation through thread‑pool tuning, data migration, and process optimization to prevent future pauses.

GCjavamemory-leak
0 likes · 17 min read
Analysis and Resolution of Full GC Issues in Inventory Center Online Business
Tencent Cloud Developer
Tencent Cloud Developer
Dec 22, 2022 · Databases

Dynamic‑Tracing Based Memory‑Leak (Growth) Analysis for MySQL‑Proxy in TDSQL

Using lightweight dynamic‑tracing tools that record allocator calls and page‑fault events, the authors diagnose a production MySQL‑proxy memory leak in TDSQL, generate focused flame‑graphs with custom memstacks and pgfaultstacks, and demonstrate a fast, source‑independent alternative to gdb or Valgrind.

LinuxMySQL-ProxyPerformance debugging
0 likes · 13 min read
Dynamic‑Tracing Based Memory‑Leak (Growth) Analysis for MySQL‑Proxy in TDSQL
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 DevelopmentTTI
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.

AndroidOOMmemory-leak
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‑PlatformDeadlock
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.

Crashdebuggingjava
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.

Backend DevelopmentNode.jshot-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 ExhaustionCache AvalancheDNS hijacking
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.

CPUDeadlockJVM
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
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
Java Interview Crash Guide
Java Interview Crash Guide
Dec 28, 2021 · Backend Development

Cutting Full GC from 40/day to Once Every 10 Days: Our JVM Tuning Story

Over a month we reduced Full GC occurrences from around 40 times per day to roughly one every ten days by systematically adjusting JVM parameters, addressing memory leaks, and fine‑tuning metaspace and young generation settings, ultimately achieving lower GC pause times and higher server throughput.

Garbage CollectionJVMPerformance Tuning
0 likes · 10 min read
Cutting Full GC from 40/day to Once Every 10 Days: Our JVM Tuning Story
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.

Redisbackendload testing
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.

Performancealgorithmdetection
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.jsPerformance Optimization
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 OptimizationJVM
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.

Backend DevelopmentThreadLocalconcurrency
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.

Performance OptimizationTensorFlow Servinggrpc
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.

Garbage CollectionNode.jsOOM
0 likes · 16 min read
Why Node.js vm Triggers OOM in V8: Hidden Compilation Cache Pitfalls
TAL Education Technology
TAL Education Technology
Sep 2, 2021 · Frontend Development

Understanding and Solving Memory Leaks in Vue Single‑Page Applications

This article explains what memory leaks are in JavaScript, how to detect them using Chrome's memory tools, enumerates common causes in Vue SPAs, and provides practical solutions and code examples—including event unbinding and keep‑alive refactoring—to effectively eliminate leaks and improve performance.

JavaScriptPerformanceSPA
0 likes · 7 min read
Understanding and Solving Memory Leaks in Vue Single‑Page Applications
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.

CGOGoroutinedebugging
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 ProfileFlutterMobile Development
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 DevToolsPerformancememory-leak
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 CollectionPerformancebest practices
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.

Garbage CollectionJVMOperations
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.

JVisualVMProfilingjava
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.

Garbage CollectionJVMPerformance Tuning
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 CollectionJVMPerformance Tuning
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.

AndroidHookingNative Memory
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 CollectionThreadLocalfinalize
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.

InfluxDBLinuxPerformance Tuning
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.

InfluxDBPerformance Tuningdatabase optimization
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.jsSQL
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.

Cache AvalancheDatabase DeadlockJVM
0 likes · 18 min read
7 Real‑World Production Failures and How to Diagnose Them Quickly
DeWu Technology
DeWu Technology
Nov 27, 2020 · Mobile Development

Analysis and Fix of Android Memory Leak Caused by AsyncTask SerialExecutor Blocking on Vivo Devices

The analysis reveals that on Vivo devices running Android 9, a static AsyncTask SERIAL_EXECUTOR blocks the UpdateBottomFlagTask in several order‑related activities, leaking the Activity context, and the fix replaces this executor via reflection with a custom parallel SerialExecutorProxy to prevent the leak.

AndroidAsyncTaskPerformance Optimization
0 likes · 14 min read
Analysis and Fix of Android Memory Leak Caused by AsyncTask SerialExecutor Blocking on Vivo Devices
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.

Backend DevelopmentThreadLocaljava
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.

Cache AvalancheDNS hijackingDatabase Deadlock
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.

Backend DevelopmentSynchronizationconcurrenthashmap
0 likes · 8 min read
When ‘No‑Comment’ Java Code Triggers a Memory Leak – A ConcurrentHashMap Study