Learn to identify JVM memory leaks in production by monitoring heap usage, analyzing GC logs, using heap dumps and runtime profiling, and applying prevention patterns such as bounded caches, proper resource cleanup, and safe reference handling to avoid OutOfMemoryError crashes.
This article recounts a three‑month deep‑dive into Docker container performance, detailing how we identified root causes such as Java container‑awareness, CPU pinning, memory limits, I/O bottlenecks, and network overhead, and applied systematic tuning of cgroups, JVM flags, Docker Compose settings, and storage/network configurations to raise CPU usage to 90% and double throughput.
During a midnight promotion launch, a forgotten TODO caused thread‑pool exhaustion and frequent Full GC, bringing down an e‑commerce service; the article presents a five‑step end‑to‑end JVM tuning methodology, from data collection to root‑cause verification and code fix, showing how to diagnose and resolve such incidents.
This guide explains how Spring Boot 3.5.6 running on JDK 21 can leverage Java virtual threads to handle millions of concurrent requests, covering the concept, environment setup, Maven configuration, enabling the feature, and a simple test controller to verify the thread model.
This guide compiles high‑frequency Java interview questions—from core language concepts and collections to JVM tuning, MySQL indexing, Redis caching, Spring frameworks, micro‑services, and MQ reliability—providing a comprehensive reference for candidates targeting small‑to‑mid‑size companies.
This comprehensive guide shows how a seasoned operations engineer can dramatically improve Tomcat stability and throughput by understanding JVM memory structures, configuring optimal JVM and connector parameters, selecting the right garbage collector, and implementing robust monitoring and diagnostics to prevent crashes and latency.
This guide details how to address Jenkins Performance plugin compatibility problems, modify CSP security policies, customize the Jenkins context path, fix git clone timeouts, resolve batch command failures, replace vulnerable JARs, run JNLP files on Windows agents, disable CSRF protection, adjust JVM memory settings, and implement disk space and build timeout optimizations.
This article explains how using the + operator for string concatenation in Java creates multiple immutable objects, why StringBuilder offers a memory‑efficient alternative, and analyzes two interview‑style code snippets with bytecode to reveal the exact number of objects each statement generates.
This article shares Beike's recent campus hiring salary data and provides a comprehensive Java backend interview guide covering HTTP response codes, session vs. cookie, runtime and checked exceptions, abstract classes vs. interfaces, StringBuilder vs. String, JVM memory structure, multithreading techniques, thread‑pool parameters, the synchronized keyword, B+‑tree indexing, and essential Linux commands.
This article details a step‑by‑step investigation of a high‑concurrency, low‑latency system whose instability was traced to long‑lasting Young‑GC pauses during massive index swaps, and explains how targeted JVM parameter tweaks, GC‑log analysis, and a lightweight Eden‑pre‑heat technique finally achieved near‑perfect availability.
After a recent deployment, a Java service began experiencing over five Full GC events per minute, traced to Log4j2’s thread‑local buffer misconfiguration and a -XX:PretenureSizeThreshold setting that forced large StringBuilder objects directly into the old generation, leading to memory pressure and frequent Full GCs.
This article records and analyzes a production incident where multiple Spring Boot microservices each consumed around 12 GB of RAM, explains why the default JVM settings caused the overload, and provides step‑by‑step troubleshooting and tuning recommendations to prevent similar memory‑usage problems.
This article guides job seekers through the autumn recruitment season, highlights bank hiring timelines and English requirements, and then provides a comprehensive Java interview Q&A covering JVM memory structures, object allocation failures, the parent‑delegation model, message‑queue usage, Spring AOP principles, and database string type differences.
This article explains the root‑cause analysis and step‑by‑step troubleshooting process for frequent Full GC events in Java applications, covering trigger mechanisms, impact assessment, common causes, monitoring tools, heap‑dump analysis, and both short‑term fixes and long‑term architectural improvements.
This article explains a step‑by‑step approach to load external JAR files into the JVM, configure Spring Boot to recognize the new classes, and choose among classpath expansion, Spring Boot's loader.path, or a custom ClassLoader, complete with Maven settings and code examples.
An in‑depth investigation of a Java service’s memory alarm reveals that a surge of temporary NioChannel objects, caused by high QPS and insufficient socket reuse, prematurely promotes objects to the old generation, leading to uncollected memory growth, and the article details the diagnosis, GC tuning, and mitigation steps.
The article walks through a simulated five‑round Java interview where the candidate designs a high‑concurrency invoice‑issuing service, covering gateway architecture, async Kafka processing, cache strategies, JVM thread‑pool and memory tuning, database‑cache coordination, microservice messaging, system design, performance optimization and AI integration, all illustrated with concrete numbers and code snippets.
Jeandle, the new open‑source JVM JIT compiler from Ant Group, uses LLVM to bring advanced optimization and code generation to Java, promising dramatic performance gains and a roadmap that includes full bytecode support and cutting‑edge Java‑specific optimizations.
Jeandle, the new open‑source LLVM‑based JIT compiler released by Ant Group, aims to integrate LLVM’s high‑performance optimizations into the JVM, offering faster execution, future roadmap details, and insights into JIT and LLVM fundamentals for Java developers.
Jeandle, the new open‑source LLVM‑based JIT compiler released by Ant Group, aims to boost Java performance by integrating LLVM’s optimization capabilities into the JVM, explaining JIT and LLVM fundamentals, its architecture, and an ambitious roadmap toward full bytecode support and advanced optimizations.
This article explains why JVM stack overflow is a critical issue, illustrates common causes such as uncontrolled recursion and massive thread creation, provides practical stack‑size tuning guidelines, special‑scenario adjustments for SpringBoot and cloud‑native deployments, and outlines diagnostic tools and monitoring metrics to detect and avoid crashes.
This article walks through a systematic, interview‑style guide for sizing and configuring JVM heap, young generation, GC choice, and related parameters to reliably support a platform that processes one million login requests per day on an 8 GB memory node.
Upgrading a Kubernetes cluster from CentOS 7.9 to Ubuntu 22.04 caused Java pods to crash with OOMKilled errors; increasing memory limits only hid the issue, and the root cause was cgroup v2 making the JVM misinterpret its resource limits, resulting in excessive threads and heap sizes. The article advises upgrading to a JVM that supports cgroup v2 or reverting the node to cgroup v1.
This article explores the JVM bytecode instructions behind Java’s synchronized keyword and CAS mechanism, detailing monitorenter/monitorexit, ACC_SYNCHRONIZED flags, static synchronization, and the underlying Unsafe.compareAndSetInt implementation with example code and analysis.
This article analyzes frequent timeout alerts caused by the getUiToken API, investigates JVM garbage‑collection pauses linked to excessive PhantomReference objects from MySQL connections, and presents configuration, code, and scheduling solutions that dramatically reduce GC latency and improve service stability.
This article explains the JVM Method Area, its purpose in storing class metadata, constants, static variables and JIT-compiled code, and details its six internal components—including the runtime constant pool, field data, method data, class data, constant data, and compiled code—providing essential knowledge for Java developers and interview preparation.
This article walks through a real‑world performance investigation, covering CMS GC misconfigurations, biased‑lock revocation delays, Netty worker thread queuing, and log‑framework overhead, while providing concrete JVM flags, code snippets, and diagnostic steps to pinpoint and resolve latency spikes.
This article provides a comprehensive walkthrough for setting up Elasticsearch 7.10 on a CentOS 7 server, covering environment preparation, installation commands, verification steps, essential configuration of paths, cluster settings, JVM heap, system limits, and best‑practice recommendations for production deployments.
An experienced ops engineer investigates a night‑time Grafana alert showing 900% CPU usage, discovers a mismatch between JVM‑detected cores and container limits, explains the root cause, and presents a three‑step solution with code snippets, monitoring tweaks, and performance results.
An 8‑year ops veteran investigates a night‑time alert showing 900% CPU usage, discovers that a JVM inside a Kubernetes pod misreads host cores while the container is limited to two CPUs, and outlines how improper thread‑pool settings and monitoring metrics caused massive throttling before presenting concrete fixes.
This tutorial explains Java class loaders—including bootstrap, platform, and system loaders—their delegation model, visibility rules, and how to create custom loaders, providing code examples and a clear overview of their role in the JVM.
This article walks through essential JVM memory and garbage‑collection settings, explaining each flag—such as -Xms, -Xmx, -XX:NewSize, and GC options—through a concrete example on an 8 GB server, and provides a complete command line configuration for optimal performance and OOM diagnostics.
This article shows how a senior architect measured the exact heap memory allocated by individual HTTP and RPC requests in a SpringBoot 2.5.4 application using JMeter load testing and detailed GC logs, revealing that a minimal HTTP call consumes about 34 KB while an RPC call can use up to 1 MB, and discusses the performance implications of payload size and logging.
This article explains how Java 8's LambdaMetafactory combines the flexibility of reflection with performance close to direct method calls, covering its usage, underlying mechanics, benchmark results, and practical trade‑offs for high‑frequency invocation scenarios.
This article explains what Java native memory is, outlines the JVM's native memory regions, describes the symptoms of native memory leaks, and provides step‑by‑step methods—including Native Memory Tracking and OutOfMemoryError analysis—to identify and resolve leaks effectively.
The article shares a detailed SF interview experience, covering typical Java interview questions such as self‑introduction, challenging projects, learning paths, abstract class vs interface, HashMap vs Hashtable, insertion steps, red‑black and B+ trees, MySQL and Redis indexing choices, large‑table optimization, JVM memory model, and the purpose of the Survivor space.
This guide explains the fundamentals of memory leaks in Java, outlines common causes in Spring Boot, and provides step‑by‑step techniques—including GC log analysis, JConsole, VisualVM, MAT, Actuator, custom endpoints, jstack, BTrace, and best‑practice recommendations—to identify, diagnose, and prevent memory leaks for stable long‑running services.
This article walks through a real‑world production case, showing how to systematically detect, analyze, and resolve severe JVM garbage‑collection pauses that caused service timeouts, by examining CPU, memory, GC logs, adjusting collector settings, and aligning JVM threads with Kubernetes resource limits.
This article analyzes 58.com’s recent business struggles and layoffs, then presents a comprehensive set of Java interview questions covering synchronized vs. Lock, JVM memory layout, garbage collection, TCP connection teardown, MySQL indexing pitfalls, and common sorting algorithms, providing detailed explanations and code examples.
The article explains the complete lifecycle of Java annotations, covering how the compiler represents them in the AST, how retention policies affect bytecode generation, how the JVM parses annotation attributes during class loading, and how dynamic proxy objects are created and used at runtime, with concrete Spring framework examples.
This article shares a real HSBC interview experience and provides in‑depth explanations of Java HashMap internals, ConcurrentHashMap locking mechanisms, differences between synchronized and ReentrantLock, JVM garbage‑collection nuances, memory‑overflow causes, and practical SQL queries for extracting top scores.
This article explains the purpose and categories of JVM argument prefixes, demonstrates common standard and non‑standard options such as -X, -D, and -XX, and shows how to use them for performance tuning, debugging, instrumentation, and custom configuration of Java applications.
This guide introduces JVM performance monitoring by explaining built‑in tools like JConsole and VisualVM, showcasing third‑party solutions such as Arthas, and providing step‑by‑step commands and screenshots to help developers quickly visualize and troubleshoot Java applications.
This guide explains why Java heap dumps miss native memory, introduces Native Memory Tracking (NMT) and tools like pmap and gdb, and provides practical code and JVM settings to detect, analyze, and prevent native memory leaks in Java programs.
This guide explains step‑by‑step how to load external JAR files into the JVM, configure Spring Boot to recognize them, and choose among four practical solutions—including classpath expansion, Spring Boot loader.path, custom class loaders, and JVM boot classpath tweaks—while highlighting their pros, cons, and required Maven settings.
This article investigates a high‑concurrency Java service that suffers from long GC pauses during large index swaps, identifies YGC Object Copy as the root cause, and presents a series of JVM tuning techniques—including MaxTenuringThreshold, InitialTenuringThreshold, AlwaysTenure, G1HeapRegionSize, ZGC, and an Eden‑preheat strategy—to achieve near‑zero service disruption and 99.995% success rate.
Full GC pauses all application threads and degrades performance; this article explains frequent Full GC causes such as memory leaks, large object allocation, old‑generation and metaspace shortages, and mis‑configured JVM parameters, and provides concrete detection tools and optimization strategies for each garbage collector.
This article explains the main conditions that cause Java objects to be promoted from the young generation to the old generation, covering age thresholds, space guarantees, dynamic age determination, and large‑object allocation rules in HotSpot JVM.
This article walks through a real‑world production case, detailing how to systematically detect, analyze, and resolve severe JVM garbage‑collection pauses in a high‑concurrency Spring Boot microservice, covering resource analysis, JVM flag tuning, G1GC migration, JMX listeners, and GC‑log investigation.
This article explains how Java's Just‑In‑Time (JIT) compilation and tiered (layered) compilation work together to transform bytecode into native code, improve runtime performance, balance startup speed, and offers practical configuration tips for fine‑tuning JVM behavior.
The article shares a personal experience of TP-Link's early campus recruitment and salary expectations, then provides a comprehensive Java backend interview guide covering class‑loader delegation, JVM memory layout, garbage‑collector types, synchronized lock mechanics, and common Redis cache pitfalls with practical solutions.
JVM’s generational garbage collection divides the heap into young and old generations, using two Survivor spaces to incrementally age objects, apply a copying algorithm, reduce fragmentation, improve memory utilization, and accelerate short‑lived object reclamation, ultimately enhancing overall GC performance.
This article explains how Azul's CRaC and ReadyNow technologies differ in approach to accelerating Java application startup, detailing the Java launch process, optimization phases, implementation requirements, and a side‑by‑side comparison of their benefits and trade‑offs.
This article explains Java's ClassLoader architecture, the parent delegation model, the three phases of class loading, dynamic loading and binding mechanisms, and demonstrates how to inspect object layout using the JOL tool, providing code examples and practical insights for JVM internals.
This article details how replacing Java's native double parsing with the Ryu and FastFloat algorithms, alongside JVM GC tuning, dramatically reduces CPU usage and latency in backend services, offering practical code examples, benchmark results, and actionable optimization strategies.
This article explains Java's lock mechanisms—including synchronized, ReentrantLock, and their JVM implementations—covers lock classifications, memory barriers, CAS, and compares them with Kotlin coroutine synchronization tools like Mutex, providing code examples and practical guidance for safe concurrent programming.
This guide explains how to launch Java processes from the command line, details key JVM tuning flags such as -X and -XX options, describes garbage collection algorithms, reference strengths, and stop‑the‑world pauses, providing practical examples and diagrams to help developers optimize memory usage and performance.
This tutorial explains the differences between Java's System.exit() and Runtime.getRuntime().halt(), detailing their shutdown sequences, impact on shutdown hooks and finalizers, providing code examples and test cases, and offering guidance on when to use each method safely.
Discover twelve practical SpringBoot performance optimization techniques—from connection pool tuning and JVM memory settings to caching, async processing, and full‑stack monitoring—each illustrated with code snippets and actionable guidance to prevent full‑table scans, OOM errors, and latency spikes in high‑traffic applications.
This article explains what JVM thread dumps are, why they are crucial for fault testing, outlines common scenarios such as deadlocks and resource leaks, and provides step‑by‑step methods—including jstack, kill‑3, VisualVM, programmatic APIs, and Fabric8‑driven Kubernetes automation—to capture and analyze them effectively.
The article explains how to achieve graceful shutdown of Spring Boot services by handling Linux kill signals, registering JVM shutdown hooks, and exposing an Actuator REST endpoint that safely releases resources, stops beans, and terminates the JVM without data loss.
When a midnight CPU alarm triggered, I logged into the server, identified runaway Java processes, profiled the JVM, refactored a costly sorting algorithm, added database indexes, containerized the service, and set up Prometheus alerts, ultimately reducing CPU usage below 30% and restoring millisecond response times.
When a midnight CPU alarm threatened service availability, I walked through rapid system checks, JVM profiling, algorithm refactoring, database indexing, Docker isolation, and Prometheus alerting to bring CPU usage back below 30% and restore millisecond‑level response times.
After caching, indexing, and async optimizations still leave a Spring Boot REST API sluggish, this guide shows how fine‑tuning JVM options—such as enabling G1GC, adjusting pause targets, compressing class metadata, shrinking thread stacks, and pre‑touching memory—can triple response speed without changing application code.
Facing frequent timeouts in a high‑throughput Java service, we traced instability to long GC pauses during massive index swaps, then systematically tuned JVM parameters, explored G1, ZGC, and custom Eden‑pre‑heating techniques, ultimately achieving near‑perfect availability without adding hardware.
This article introduces the SootUp library, explains how to configure its Maven dependencies, describes the Jimple intermediate representation, and demonstrates how to use SootUp's API to analyze Java source code, bytecode, and method bodies through a series of code examples.
This article compares the compilation and runtime processes of C and Java programs, explains Java's class loading, linking, initialization, memory layout, execution engine components, and native interface, and highlights why Java startup is slower than native C execution.
This article uses real‑world analogies to dissect the three core challenges of Java concurrency—ordering, visibility, and atomicity—and explains how hardware instructions, JVM mechanisms, and Java SDK tools such as locks, CAS, and waiting/notification utilities provide efficient solutions.
This article humorously introduces a common interview scenario and then provides a comprehensive overview of JVM garbage collection, covering memory regions, GC roots, collector types like ParNew, G1, CMS, tuning parameters, code examples, and practical tips for diagnosing and optimizing GC behavior.
This article explains the concept of Java's Runtime.addShutdownHook, details its underlying implementation in the Runtime and ApplicationShutdownHooks classes, demonstrates usage with code examples, discusses typical application scenarios, potential risks of long‑running hooks, and provides best‑practice recommendations for safe JVM shutdown handling.
This article explains the purpose and inner workings of Java's Runtime.addShutdownHook, walks through the Runtime and ApplicationShutdownHooks source code, demonstrates practical usage with examples, discusses common scenarios, potential risks, and best‑practice solutions for reliable resource cleanup during JVM shutdown.
The article lists the most frequent Java OutOfMemoryError variants, explains their root causes and typical scenarios, provides concrete code examples that trigger each error, and offers practical troubleshooting steps and JVM tuning recommendations for interview preparation.
A friend who landed a 16K job in a first‑tier city shares more than 30 interview questions he encountered across ten+ companies, covering JVM internals, performance tuning, concurrency, design patterns, database locking, distributed transactions, and system reliability.
This article explores the puzzling "prevent gc" comment in RocketMQ source code, explains how Thread.sleep(0) interacts with JVM safepoints, distinguishes counted and uncounted loops, and demonstrates practical experiments that reveal why altering loop variables can change GC behavior.
This article explains why the JVM throws java.lang.OutOfMemoryError: GC overhead limit exceeded, outlines common causes such as traffic spikes, memory leaks, insufficient heap and inefficient GC, and provides practical solutions and debugging steps to diagnose and fix the issue.
java.lang.OutOfMemoryError: Requested array size exceeds VM limit occurs when a Java program attempts to allocate an array larger than the JVM's available heap, and can be mitigated by increasing heap size, optimizing code, or processing data in smaller batches.
The article presents a Spring Boot experiment measuring per‑request heap memory usage for HTTP and RPC calls, details the JMeter test setup, analyzes GC logs, reports findings such as ~34KB per HTTP request and 0.5‑1MB per RPC request, offers optimization recommendations, and also includes promotional material for AI‑related products.
This article examines why storing phone numbers as Java Strings rather than ints yields better memory usage, semantic correctness, and JVM-level performance, discussing primitive vs reference types, bytecode differences, string pooling, and real‑world case studies.
java.lang.OutOfMemoryError: Metaspace occurs when the JVM's native Metaspace exceeds its configured limit, often due to excessive dynamic class generation, large numbers of loaded classes or classloader leaks, and can be mitigated by increasing Metaspace size, fixing memory leaks, and optimizing class loading.
This article explains the Java memory pool model, common Out‑of‑Memory errors, their root causes, tuning parameters, and real‑world case studies to help developers diagnose and resolve OOM issues in containerized Java applications.
This article explains the JVM method area concept, its implementation as the permanent generation in JDK 1.7, the limitations of that approach, and how JDK 1.8 introduced metaspace using native memory to improve class metadata management and avoid out‑of‑memory errors.
When a midnight CPU alarm threatened a core Java service, I walked through rapid system checks, JVM profiling, algorithm refactoring, database indexing, Docker isolation, and enhanced monitoring to bring CPU usage back below 30% and restore service stability.
This article explains Java virtual threads introduced by Project Loom, compares them with platform threads in terms of memory usage and creation time, provides code examples for creating and managing virtual threads, and outlines practical guidelines and use‑cases for high‑concurrency backend applications.
This article explains Java's dynamic ClassLoader mechanism, outlines the hierarchy of built‑in loaders, details frequent problems such as ClassNotFoundException, NoClassDefFoundError, ClassCastException and version conflicts, and provides practical troubleshooting steps and best‑practice recommendations for reliable class loading.
This article explains how the java.lang.ClassLoader#loadClass() API works, why frequent concurrent calls can cause thread blocking due to internal synchronization, demonstrates the issue with a sample multithreaded program, analyzes thread‑dump data, and provides practical solutions to mitigate the performance problem.
This article explains why Spring Boot applications can consume up to 12 GB of RAM, demonstrates how to inspect JVM memory with tools like jps and jmap, clarifies default heap size calculations, and provides practical steps to tune JVM parameters for production stability.
This article explains the low‑level implementation of Java's synchronized keyword, covering monitorenter/monitorexit bytecode, object header structures, Mark Word layouts, and the evolution from heavyweight locks to biased and lightweight locks with lock‑upgrade mechanisms.
This article explains the JVM's tiered compilation mechanism, detailing the client (C1) and server (C2) JIT compilers, the five compilation levels, code cache organization, relevant JVM flags, and demonstrates method compilation lifecycle through illustrative Java code examples and log analysis.
The article reviews key Java backend interview topics—including thread‑safe collections, JVM memory layout and heap tuning, Full GC troubleshooting, Java 8 features, optimistic locking, stock‑over‑sell handling with Redis, MySQL scaling, cache‑consistency patterns, anti‑bot safeguards, and Bloom filters—while noting JD’s recent 30% salary hike for algorithm engineers.
An in‑depth look at how the JVM stores object references, comparing handle‑based access with direct pointer access, highlighting their performance trade‑offs, memory overhead, and impact on garbage collection to help developers choose the most suitable approach for their applications.
This article explains how to size and configure JVM options—including heap size, young generation, GC algorithm, thread stack, and metaspace—for a backend service that processes one million login requests per day on an 8 GB machine, providing step‑by‑step calculations, practical examples, and optimization tips.
This curriculum outlines a 25‑week advanced Java engineering program covering performance optimization, JVM internals, concurrency, distributed storage, MySQL and NoSQL databases, Docker, Kubernetes, microservices, Spring framework deep dives, Nginx, Elasticsearch, Redis, messaging systems, CI/CD tools, and hands‑on project implementation to build high‑performance, scalable backend systems.
This article explains the CRaC (Coordinated Restore at Checkpoint) technology for Java applications, describing its principles, supported environments, practical steps for enabling it with Spring Boot, and use‑case scenarios that dramatically reduce JVM startup time.
The article explains the concept of GC Roots in the JVM, detailing the four main types—stack variables, static fields, constant pool references, and JNI references—along with code examples, and describes how these roots determine object liveness during garbage collection.
This article walks through a step‑by‑step troubleshooting process for JVM Out‑Of‑Memory (OOM) incidents, covering symptom identification, monitoring tools like top, jstat, and jmap, root‑cause analysis, and actionable recommendations to prevent future memory leaks.
This article explains the main Java garbage collection algorithms—Mark‑Sweep, Mark‑Copying, Mark‑Compact, and Generational Collection—detailing their principles, advantages, and drawbacks, helping developers choose the appropriate strategy for efficient memory management in backend applications.
This article explains the core principles of Java class loading, including the uniqueness of Class objects per ClassLoader, various loading sources such as dynamic generation, network, ZIP archives, and databases, the lifecycle stages, delegation model, isolation, and practical recommendations for safe and efficient deployment.
This article explains the structure, contents, and characteristics of Java's Class constant pool and runtime constant pool, detailing how literals and symbolic references are stored, how the runtime pool can be dynamically modified, and the impact on memory and JVM linking.
The CMS (Concurrent Mark Sweep) garbage collector, designed for low‑latency old‑generation reclamation, suffers from memory fragmentation, floating garbage, high CPU usage, concurrent‑mode failures, Full GC risks, and complex tuning, making it unsuitable for many production Java workloads.
Because phone numbers are identifiers that can contain symbols and exceed the numeric range of an int, storing them as a String—despite higher memory use—is semantically correct, avoids overflow, preserves formatting, and benefits from JVM string pooling, making String the preferred type in most Java applications.
