Byteman is a dynamic Java fault‑injection tool that lets developers simulate network delays, service crashes, and resource exhaustion without altering source code, offering seamless integration with JUnit/TestNG, detailed rule definitions, and convenient shell scripts for installing, submitting, and removing fault‑injection rules.
This comprehensive guide walks you through systematic JVM memory issue diagnosis, covering initial data collection, analysis of heap, metaspace, direct memory, stack problems, and practical command‑line tools, while offering actionable tips and real‑world examples for effective troubleshooting.
This article provides a comprehensive overview of garbage collection techniques, covering reference counting, reachability analysis, generational management, copy, mark‑sweep, and mark‑compact algorithms, and explains the JVM's serial, parallel, CMS, and G1 collectors along with their operational characteristics and trade‑offs.
This article walks through the anatomy of a Java Virtual Machine crash, explains how to read the generated hs_err_pid log and core dump, and provides practical debugging steps—including code examples, signal analysis, register context, and GDB commands—to pinpoint and resolve the root cause.
This article presents a SpringBoot-based experiment measuring the heap memory allocated per HTTP request, detailing the setup with JMeter, JVM GC logging, observed memory usage of roughly 34 KB per request, analysis of GC frequency, and concludes with recommendations on logging and memory optimization, while also promoting related AI services and community resources.
This article explains why, in containerized Java applications, the JVM flag -XX:+ExitOnOutOfMemoryError is generally preferred over -XX:+HeapDumpOnOutOfMemoryError, detailing the trade‑offs, operational benefits, and how Kubernetes probes and monitoring can ensure fast failure, rapid recovery, and user‑transparent service continuity.
This article explains how to launch Java processes from the command line, explores JVM -X and -XX tuning parameters, details garbage‑collection algorithms, describes reference strengths, and clarifies object reachability to help developers optimize Java application performance.
This article explains why JVM tuning is essential for performance, outlines a step‑by‑step optimization workflow—including GC monitoring, heap dumps, parameter tuning, and tool usage—provides a concrete Java code example that triggers memory pressure, and shares effective JVM flags to prevent out‑of‑memory errors.
The article reviews Groovy's evolution from a top‑ranked general‑purpose language to a domain‑specific language, highlighting its key applications, syntax advantages, dynamic typing, and why it now serves best as a DSL despite a stagnant ecosystem.
This article explains the internal mechanisms of JVM garbage collection, covering oopMap, safepoints, saferegions, three‑color marking, memory sets, write barriers, and the design of low‑latency collectors such as Shenandoah and ZGC, and provides practical tuning advice.
This article provides a thorough Java backend interview preparation guide covering collection frameworks, JVM architecture and garbage‑collection, operating‑system thread vs process concepts, TCP handshake and termination, MySQL transaction ACID properties and concurrency anomalies, Redis cache consistency strategies, and a sample algorithm problem.
This article provides a comprehensive overview of Java garbage collection, covering the principles of reference counting and reachability analysis, detailing major GC algorithms such as mark‑sweep, copying, and mark‑compact, explaining object allocation strategies, and reviewing traditional and modern collectors like Serial, CMS, and G1, with practical tuning tips for each.
This article details a step‑by‑step investigation of a Spring Boot application that consumed far more physical memory than its 4 GB heap limit, revealing a native‑memory leak caused by MCC's package‑scanning using Reflections and the Spring Boot ZipInflaterInputStream, and explains how configuration changes and newer Spring Boot versions resolve the issue.
The article details how a production Spring Boot system consumed excessive memory due to default JVM heap settings, explains the underlying JVM defaults, demonstrates diagnostic commands, and provides practical recommendations for configuring JVM parameters and monitoring memory usage to prevent similar issues.
The guide equips candidates for backend interviews by covering essential networking (HTTP/HTTPS, TLS handshake, status codes, headers, OCSP, session resumption, CSRF), RPC frameworks, Java class-loading and JVM memory/GC, OS process/thread scheduling, Spring bean lifecycle, Redis caching pitfalls, and MySQL indexing and query optimization.
The article explains Java's parent delegation model for class loaders, its benefits for stability and security, how to break it by customizing loadClass or using thread‑context class loaders, and illustrates common scenarios such as JNDI, JDBC and Tomcat's own class‑loader hierarchy.
The article explains how Java’s invokedynamic instruction and LambdaMetafactory create synthetic classes and MethodHandles to implement Lambda expressions, detailing compilation steps, stateless versus stateful handling, performance implications, and the requirement for captured variables to be effectively final.
This article explains the JVM memory architecture—including heap, stack, native stack, method area, and program counter—detailing heap generations, object allocation strategies, object layout, reference types, and the complete lifecycle of Java objects from creation to garbage collection.
This article introduces AviatorScript, a high‑performance, lightweight JVM‑based scripting language, covering its origins, key features, quick‑start setup, core syntax for numbers, strings, booleans, control flow, functions, and real‑world use cases such as client version control, marketing rules, and order risk management.
The author recounts a sudden CPU spike on a Kubernetes pod caused by excessive JVM garbage collection, walks through step‑by‑step diagnostics using top, thread inspection, jstack, and network file transfer, identifies a flawed Excel export loop, and shares the fix and lessons learned.
This article documents a production incident where multiple Spring Boot services each consumed around 12 GB of memory, explains how to diagnose the issue using jps and jmap, details default JVM heap size calculations, and provides recommendations for configuring JVM parameters to prevent excessive memory usage.
This article explains what memory leaks are in Java, outlines common causes such as unreleased resources, static collections, misuse of ThreadLocal, improper variable scope, inner‑class references and off‑heap memory, and provides practical solutions and best‑practice recommendations to avoid them.
This article explains the JVM memory architecture, object lifecycle, young and old generation garbage‑collection mechanisms, tuning goals such as low latency, high throughput and large heap, and provides practical advice on monitoring, common memory‑related problems, and choosing appropriate collectors for different application scenarios.
This article details a multi‑level caching architecture—spanning CDN, Nginx, Redis, JVM cache, and MySQL—that dramatically speeds up product information access in e‑commerce systems while enhancing reliability and scalability.
This article explains the various forms of Java OutOfMemoryError, their underlying causes such as heap exhaustion, GC overhead, metaspace limits, and native allocation failures, and provides practical solutions and code snippets to diagnose and resolve each scenario.
This article provides an in-depth overview of common backend interview topics, covering MySQL index structures and storage engines, Redis single‑threaded design and persistence mechanisms, Java transaction ACID properties, SpringBoot auto‑configuration principles, JVM memory regions, class loading, and garbage‑collection algorithms, all illustrated with code examples.
This article explains how Spring Boot 3.2 can be accelerated with Class Data Sharing, virtual threads, GraalVM native images, ProblemDetail error handling, and new observability features, providing practical commands and code examples for faster startup, lower memory usage, and richer monitoring.
This article explains Java's lock escalation process—covering biased, lightweight, and heavyweight locks—their underlying mechanisms, performance benefits, and the conditions under which each lock type is applied in multithreaded applications.
Although many claim that using try‑catch in Java severely degrades performance, this article examines JVM exception handling, bytecode, and JIT optimizations, presents detailed test code and results under interpretation and compilation modes, and concludes that try‑catch has negligible impact when no exception occurs.
This article explores the JVM's tiered compilation mechanism, detailing how the interpreter, C1 and C2 compilers, code cache segmentation, and various JIT optimizations such as inlining, loop unrolling, escape analysis, and safepoint handling affect startup speed and runtime performance, with practical parameter tuning tips.
This article details a month‑long investigation and step‑by‑step tuning of a Java server's JVM parameters, memory‑leak fixes, and metaspace adjustments that reduced FullGC from dozens of times daily to a single occurrence every ten days while improving overall throughput.
This guide explains how to tune Tomcat 8.5 by adjusting server.xml parameters such as maxThreads, acceptCount, maxConnections, and connectionTimeout, while also covering related Linux kernel settings, file‑descriptor limits, and JVM options to achieve optimal concurrency and response times.
This article provides a comprehensive, step‑by‑step explanation of the JVM class‑loading mechanism, covering the five phases—Loading, Verification, Preparation, Resolution, and Initialization—along with diagrams and detailed descriptions of each operation performed by the JVM.
This article provides a comprehensive overview of Java's G1 and ZGC garbage collectors, explaining their memory layout, internal structures such as regions, card tables, and RSet, detailing Young and Mixed GC processes, three‑color marking, SATB, incremental updates, and the low‑pause design of ZGC.
The article documents a production incident where each Spring Boot service consumed about 12 GB of memory on a 64 GB server, explains how default JVM settings caused the issue, and provides step‑by‑step troubleshooting and tuning guidance to reduce memory usage.
This article provides a comprehensive overview of Java reflection, explaining its definition, underlying JVM mechanisms, practical usage with code examples, detailed source‑code walkthrough, advantages and disadvantages, and its critical role in popular frameworks such as Spring.
Exploring the differences between PhantomReference and WeakReference in Java’s ZGC, this article explains how ZGC’s concurrent phases and the should_drop method use distinct bitmap bits to determine object liveness, revealing why only PhantomReference reliably tracks object reclamation in certain finalization scenarios.
This article explains how the JVM creates and manages FinalReference objects, how they interact with the finalize() method, and how the ZGC and other GC phases discover, revive, and eventually reclaim objects, detailing the roles of ReferenceHandler, FinalizerThread, and related internal data structures.
This article explains how Java's Thread.sleep(0) works, its native implementation, why it is used in RocketMQ source code, and how the call influences JVM garbage‑collection, safe‑point insertion, and CPU scheduling to improve multithreaded performance.
This article explains how ZGC in OpenJDK 17 decides whether to reclaim SoftReference objects, detailing the unconditional clearing scenarios, the policies governing SoftReference lifetimes, and how the JVM quantifies memory pressure using heap size and the -XX:SoftRefLRUPolicyMSPerMB flag.
This article analyzes the memory increase observed after enabling Log4j2 asynchronous logging in Java services, examines root causes such as thread‑local reuse and large char[] allocations, and presents configuration and code changes—including disabling thread‑locals and limiting message size—to prevent heap growth and improve performance.
This article explains what Java Class Data Sharing (CDS) is, walks through training and running a Spring Boot application with CDS, and demonstrates how startup time can be reduced by nearly one second, while comparing CDS with CRaC and GraalVM for Java performance optimization.
In an exclusive SD Times interview, Luis Majano explains how BoxLang, a modern, modular and event‑driven JVM language, aims to revitalize dynamic language development with high performance, tiny core size, extensive tooling, and a thriving open‑source ecosystem.
This article explains the core concepts of Java thread pools, walks through the ThreadPoolExecutor class hierarchy and key methods, analyzes thread‑pool states and execution flow, and provides practical guidelines for configuring parameters, avoiding memory leaks, handling task dependencies, and managing exceptions in production systems.
The author celebrates landing a new job while emphasizing that mastering Java's garbage collection—identifying and reclaiming memory from unreachable objects via algorithms like reference counting or reachability analysis—is essential for robust backend development and preventing memory overflow.
This article explains why upgrading to JDK 17 and switching to the low‑latency ZGC garbage collector can dramatically reduce pause times and improve throughput, compares GC and CPU metrics against G1, and provides step‑by‑step installation and JVM tuning instructions with code examples.
This article demonstrates how to use the JDK's built-in command-line and graphical tools—such as jps, jinfo, jvisualvm, jstat, jstack, and jcmd—to monitor JVM performance, analyze GC behavior, inspect thread stacks, and troubleshoot memory and configuration issues in Java applications.
This article explains the theoretical and practical limits of Java String length, covering compiler restrictions, UTF‑8 encoding effects, constant‑pool constraints, runtime constructor limits, memory consumption, and the JDK9 optimization that changes internal storage.
This article compiles a set of Java interview questions covering the differences between ArrayList and LinkedList, the internal workings and resizing of HashMap, concurrency primitives like synchronized and ReentrantLock, JVM memory layout, garbage‑collection algorithms, reference types, and Redis persistence and distributed‑lock mechanisms.
This article explains the purpose, usage patterns, JVM-level object header and monitor mechanisms, lock state transitions, and lock‑upgrade strategies of Java's synchronized keyword, providing code examples and visual diagrams to illustrate how thread synchronization is achieved internally.
This article explains how Java's System.gc triggers full or concurrent garbage collection in NIO scenarios, detailing the JVM's handling of out‑of‑memory errors during memory‑mapped file operations and direct buffer allocations, and examines the behavior across various garbage collectors such as Serial, Parallel, G1, ZGC, and Shenandoah.
This article explains how to optimize Tomcat by adjusting server.xml parameters such as maxThreads, acceptCount, maxConnections, and connectionTimeout, while also covering related Linux kernel settings, file descriptor limits, and JVM options to achieve balanced performance for both CPU‑bound and I/O‑bound workloads.
This article details a step‑by‑step investigation of a container whose memory usage spiked to 99% due to large objects being allocated to the old generation under G1GC, explains the root cause, demonstrates reproducible tests with JVM flags and monitoring tools, and provides practical mitigation strategies.
The article explains JVM runtime memory regions, heap allocation and generational layout, object reference types, major garbage‑collection algorithms and collectors, class‑loading phases, and provides practical tuning commands and case studies for optimizing GC pauses, preventing memory leaks, and diagnosing performance bottlenecks.
This article provides a comprehensive guide to JVM internals, covering runtime data areas, heap segmentation, object allocation, reference types, class loading phases, garbage collection algorithms, collector choices across JDK versions, performance tuning commands, and practical troubleshooting techniques for production Java applications.
The article offers a thorough overview of Java 8 memory management, detailing JVM memory regions, object eligibility, major garbage‑collection algorithms and generational models, comparing Serial, Parallel, CMS and G1 collectors, and presenting practical heap‑dump analysis techniques for diagnosing leaks and performance issues.
This article explains six typical OutOfMemoryError situations in Java—heap, native thread, stack overflow, direct buffer, GC overhead, and Metaspace—provides code examples that trigger each issue, shows the resulting exception messages, and offers practical tips such as using thread pools, limiting recursion depth, adjusting GC settings, and configuring Metaspace to avoid these memory problems.
This article explores six typical OutOfMemoryError situations in Java—including heap, stack, direct memory, GC overhead, and metaspace issues—explains their root causes, provides reproducible code examples, and offers practical tips to avoid or mitigate each problem.
This comprehensive guide presents a systematic, step‑by‑step process for diagnosing JVM memory problems—including heap, Metaspace, DirectMemory, JNI memory, and stack issues—using Alibaba Cloud ARMS, ATP, standard JDK tools, and best‑practice commands to quickly locate root causes and apply effective solutions.
This article explains why JVM tuning matters, identifies scenarios that require tuning such as performance bottlenecks, memory overflows, and concurrency issues, and then details monitoring and diagnostic tools—including JDK command‑line utilities and third‑party solutions—followed by a comprehensive guide to JVM parameters, garbage‑collector selection, and practical ways to apply these settings in production environments.
This guide explains how JVM determines heap size on physical machines versus containers, compares behavior of different JDK releases, and provides concrete Docker commands and JVM flags—such as -Xms/-Xmx, -XX:+UseCGroupMemoryLimitForHeap, and MaxRAMPercentage—to reliably control memory usage in containerized Java applications.
ZingJDK, Azul’s high‑performance commercial JDK built on OpenJDK, combines ReadyNow® pre‑warming, the LLVM‑based Falcon JIT compiler, the pause‑free C4 concurrent compacting garbage collector, and a cloud‑native off‑load compiler to deliver dramatically faster startup and execution across JDK 7‑21, though it lacks dynamic Attach support and requires a commercial license.
The article explains that Dubbo’s zero‑capacity SynchronousQueue causes a thread‑pool “EXHAUSTED” error when incoming requests outpace consumption, often triggered by slow DB queries, lock contention, or network jitter, and that JVM stop‑the‑world pauses fill the OS TCP receive buffer, creating a post‑pause traffic burst that overwhelms the pool, with diagnostics using safepoint statistics.
This article explains the JVM memory model, detailing the five runtime data areas—heap, method area, JVM stack, native method stack, and program counter—along with their structures, configuration parameters, and roles in Java execution and performance tuning.
Over a month of systematic JVM tuning, the author reduced FullGC frequency from 40 times per day to once every ten days, halved YoungGC time, identified and fixed a memory leak caused by anonymous inner‑class listeners, and documented the step‑by‑step optimization process with configuration changes and performance results.
This article documents a month‑long investigation and tuning of a Java backend server, detailing how FullGC frequency was cut from dozens per day to a handful by adjusting heap parameters, fixing a memory‑leak caused by anonymous inner‑class listeners, and optimizing metaspace settings.
This article explains Java's parent delegation mechanism—a core part of the JVM class‑loading process—detailing its purpose, three main benefits (avoiding duplicate loading, ensuring security, improving efficiency), and the step‑by‑step loading workflow illustrated with diagrams.
This article explains the main Java JVM garbage collectors—including Serial, Parallel, CMS, G1, ZGC, Epsilon, and Shenandoah—detailing their architectures, pause characteristics, suitable workloads, and key advantages, helping developers choose the right collector for different application sizes and latency requirements.
This guide explains why Spring Boot applications consume memory, shows how to configure the JVM and Tomcat settings, and demonstrates using Docker‑compose to apply these tweaks, enabling developers to reduce local memory usage by more than 40% and speed up development cycles.
This article provides a comprehensive overview of the Java Virtual Machine, detailing its architecture, class loading process, runtime data areas, and execution engine, including interpreter and JIT compilation, to help readers grasp JVM fundamentals for Java development and interview preparation.
This article provides a detailed explanation of Java’s parent delegation model, covering its definition, visual diagrams, advantages and disadvantages, and a six-step loading process, helping readers understand how class loaders prioritize parent loaders to ensure security and avoid duplicate class loading.
This article walks through a real‑world G1 GC incident where massive humongous object allocations caused old‑generation memory spikes at night, explains the underlying JVM memory layout, shows how to trace the problem with heap dumps and monitoring data, and offers practical tips to avoid similar issues in Java applications.
This article explains how to estimate capacity, choose appropriate garbage collectors, and configure JVM memory settings—including heap size, young generation, thread stack, and GC options—for a service that processes one million login requests per day on a node with 8 GB of RAM, providing step‑by‑step guidance and example command lines.
This guide explores the JDK command‑line utilities located in %JAVA_HOME%\bin, explaining how tools such as jps, jstat, jinfo, jmap, jhat and jstack can be used to monitor JVM processes, analyze performance bottlenecks, inspect memory usage, generate heap dumps, and adjust runtime parameters for more efficient and stable Java applications.
This article explains how to monitor, interpret, and optimize Java Garbage Collection by using JDK flags, IDE configurations, and the gceasy.io visualizer, providing step‑by‑step guidance, sample logs, and performance metrics for effective JVM tuning.
This article explains how Java achieves "write once, run anywhere" through platform‑independent bytecode, describes the .class file structure, introduces tools for viewing bytecode, and provides detailed guidance on using the ASM library’s Core and Tree APIs for bytecode enhancement, including practical code demos and application scenarios.
This article explains how JVM synchronized locks and MySQL row locks can interact to cause deadlocks, demonstrates the problem with sample Spring code, shows the resulting lock‑wait timeout exception, and provides a refactoring solution to avoid the deadlock.
When a production container suddenly hit over 90% CPU and excessive JVM garbage collection, the author walks through entering the pod, using top and top‑H to locate the offending thread, extracting its stack with jstack, downloading the data via a simple HTTP server, and ultimately discovering an Excel export routine that caused massive object allocation, fixing the code and restoring stability.
This article explains why a Java method that returns a value inside a try block still yields the original value when a finally block modifies the variable, using bytecode inspection, protection mechanisms, and JVM exception‑table behavior to reveal the underlying execution order and performance implications.
A Java rule‑engine experiences occasional 1‑2 second Young GC pauses after warm‑up, caused by dynamic promotion thresholds that trigger massive object promotion, and the article explains the root cause, demonstrates log analysis, and provides JVM tuning steps to eliminate the long pauses.
This article explains why Java processes in Kubernetes pods often encounter OOMKilled despite correct JVM heap settings, analyzes the discrepancy between JVM‑reported memory and container metrics, and provides practical steps such as adjusting MaxRAMPercentage and pod memory limits to stabilize memory usage.
This article explains how HotSpot's C1 and C2 JIT compiler threads work, why they can consume excessive CPU, and provides practical JVM tuning options—including tiered compilation, code‑cache sizing, and compiler‑thread adjustments—to mitigate performance issues.
This article explains the three JVM termination modes, how to use shutdown hooks and Spring's lifecycle events to implement graceful shutdown of HTTP, RPC and MQ entry points, manage thread‑pool termination, and avoid resource‑leak or inconsistent state during service redeployment.
This article explains the Java class file format, including its magic number, version, constant pool, access flags, fields, methods, and attributes, and then details how the JVM loads, verifies, prepares, resolves, and initializes classes, manages object memory layout, and executes bytecode using a stack‑based interpreter.
This article walks through a real‑world investigation of a pod whose CPU spiked to over 90%, detailing how abnormal JVM garbage‑collection patterns were identified, traced to a specific Java thread, and resolved by fixing an inefficient Excel export routine.
This article explains the G1 garbage collector’s heap layout, collection cycles, pause prediction, log analysis, and monitoring tools, helping Java developers diagnose and resolve performance issues such as frequent restarts, OOM, CPU spikes, and periodic latency spikes.
This article explains the full spectrum of Java locking mechanisms—including pessimistic, optimistic, distributed, reentrant, spin, read/write, fair vs. non‑fair, JVM lock states, and optimization techniques—detailing their principles, use‑cases, SQL/Redis examples, and performance trade‑offs.
This article details Qunar's systematic approach to reducing service complexity and code volume by half, covering background challenges, two‑phase planning, criteria for merging or deleting services, tooling such as Serviceability Agent for method‑level analysis, automated and semi‑automated deletion workflows, verification steps, and the measurable performance gains achieved.
This article explains the common Java OutOfMemoryError types—including heap space, GC overhead limit exceeded, Metaspace, CodeCache, Direct Memory, and Linux OOM Killer—detailing their causes, symptoms, and step‑by‑step troubleshooting techniques for backend developers.
This article explains the various Java OutOfMemoryError types—including Java heap space, GC overhead limit exceeded, Metaspace, CodeCache, Direct Memory, and Linux OOM Killer—describes their causes, typical symptoms, and provides step‑by‑step troubleshooting and mitigation strategies for developers.
The article details a step‑by‑step performance investigation and optimization of a Spring‑based ToB system, covering slow SQL, thread‑pool tuning, JVM memory adjustments, excessive logging, and bean‑creation overhead, ultimately improving throughput from 50 req/s to nearly the required 500 req/s.
This article introduces Java’s bytecode fundamentals, explaining how the JVM translates compiled class files into platform‑independent instructions, the role of dynamic linking, stack frames, operand stacks, and common bytecode mnemonics, while providing code examples and visual diagrams to deepen understanding.
After migrating a project to the MDP framework based on Spring Boot, the author observed swap overuse and physical memory far exceeding the 4 GB heap; using JVM native memory tracking, gperftools, strace, pmap, and a custom allocator, they traced a native‑memory leak to Spring Boot’s ZipInflaterInputStream during JAR scanning and resolved it by limiting scan paths.
A scheduled task system that frequently accesses MySQL and cache crashes at night due to a SIGSEGV in the HotSpot JVM caused by JIT compilation of hotspot code, and the article explains the JVM internals, JIT behavior, and provides configuration and driver downgrade solutions to prevent the failure.
This article provides a comprehensive introduction to the Java Virtual Machine, covering its architecture, core principles, services such as garbage collection and security, and real‑world applications ranging from enterprise systems and Android apps to big‑data frameworks and game servers.
The G1 Garbage Collector, introduced in Java 7 update 4, replaces CMS by using a region‑based design that minimizes pause times and improves throughput, and a detailed video with diagrams and code examples is provided to deepen understanding of its operation.
This article explains what Java OutOfMemoryError (OOM) is, outlines the most common OOM types such as Java heap space, GC overhead limit, Metaspace, and native thread exhaustion, provides sample code for each, and suggests basic mitigation strategies like adjusting JVM options or optimizing code.
The default Java object hashCode() implementation is immutable and unchanged by garbage collection, while custom overrides must keep contributing fields constant to avoid map errors, and the OpenJDK native implementation stores the hash in the object header using a Marsaglia XORshift algorithm.
This article explains how the Java Virtual Machine achieves platform and language independence, details the compilation process from source code to class files, and provides an in‑depth analysis of the class file format, constant pool, bytecode instructions, access flags, and related metadata.