This article explains the inner workings of Java's CMS and G1 garbage collectors, detailing their four-phase processes, the need for stop‑the‑world pauses, strategies like incremental update and SATB to handle missed marks, and compares their advantages, drawbacks, and suitable replacement scenarios.
This article explains how to use JMH for precise Java micro‑benchmarks, covering JVM warm‑up, project setup with Maven, writing benchmark methods, configuring annotations, running tests, interpreting results, and provides practical code examples and tips for reliable performance measurement.
Explore the structure of Java's memory regions—including the program counter, stacks, heap, and method area—along with allocation algorithms, object layout, garbage collection roots, and common pitfalls such as memory leaks and StackOverflowError, providing a comprehensive guide for JVM developers.
A production incident on an elastic‑cloud deployment revealed that setting the JVM Metaspace limit to 64 MiB, while the application required around 76 MiB, triggered continuous Full GC, causing stop‑the‑world pauses, full‑line time‑outs, and a costly rollback.
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.
This article explains Java garbage collection fundamentals, covering why GC is needed, how it works, reference types, major collection algorithms, generational strategies, specific collectors like CMS and G1, and practical tuning and allocation rules for JVM memory management.
This article explains the Java class loading lifecycle, the different built‑in and custom ClassLoaders, the parent‑delegation model, reasons for breaking it (e.g., JDBC and Tomcat), how to implement custom loaders, hot‑deployment techniques, and includes typical interview code questions.
This article explains how to analyze, diagnose, and optimize performance problems in production business systems, covering the typical causes such as high concurrency, data growth, hardware limits, and environment changes, and detailing practical steps for hardware, OS, database, middleware, JVM tuning, code review, and APM monitoring.
The article explains the upcoming Java Valhalla project, detailing how value objects, primitive classes, and specialized generics will reshape the JVM’s type system, reduce memory overhead, and introduce new value‑class semantics for more efficient Java programming.
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.
The article thoroughly explains Android ART’s Concurrent Copying (CC) garbage collector—its terminology, correctness and progress requirements, engineering challenges, classic and Android‑specific algorithms, region‑based design with bump‑pointer allocation, performance benefits such as 32% lower heap usage and sub‑millisecond pauses, and its trade‑offs including doubled reserved heap space and migration overhead.
This article explains the Java Valhalla project, its upcoming value objects, primitive classes, and specialized generics, discusses the limitations of Java's type system and object headers, and introduces the concept and features of value classes with code examples.
This article explains the theory behind JVM garbage collection algorithms, details various collectors such as Serial, Parallel, CMS, and G1, compares their strengths and weaknesses, and explores advanced concepts like three‑color marking, write barriers, SATB, and memory management parameters.
This article provides concise English explanations for 33 common Java interview questions, covering the differences between JDK/JRE/JVM, the main method signature, OOP principles, memory management, access modifiers, collections, and many other core Java concepts.
This article provides a thorough, step‑by‑step exploration of the Java Virtual Machine, covering official documentation, the G1 garbage collector, HotSpot architecture, class file structure, constant‑pool parsing, bytecode inspection with hexdump and javap, and prepares readers for deeper JVM class‑loading concepts.
This article provides a comprehensive overview of the Java Virtual Machine, covering its core responsibilities, runtime memory layout, class‑loading process, object allocation and layout, garbage‑collection theories and algorithms, common collectors, useful JVM tools, and tuning parameters.
This article explains the complete Java class loading lifecycle—including loading, verification, preparation, resolution, initialization, usage, and unloading—details the seven scenarios that trigger active loading, illustrates the parent delegation model, and provides code examples for custom and Tomcat class loaders.
This article explains the JVM runtime memory areas, the fundamentals of garbage collection, generational heap organization, and the characteristics of major GC collectors, providing practical insights and optimization tips for Java developers seeking to understand and improve JVM performance.
This article explains the evolution of Java synchronization mechanisms from the classic synchronized keyword to lightweight, biased, and heavyweight locks, explores how lock states transition, the impact of hashCode and wait, and why biased locking is being phased out in modern JDKs.
The article details three Xianyu backend incidents where Full GC pauses caused latency spikes or outages, analyzes root causes ranging from survivor space shortage and mis‑tuned CMS to oversized async Log4j events and massive string‑concatenation logs, and presents remediation steps such as switching to G1GC, adjusting Log4j settings, and using parameterized logging to eliminate the pauses.
This article explains the causes of Java out‑of‑memory problems, introduces essential diagnostic commands and memory‑analysis tools, and walks through a real‑world case study that shows how to locate, analyze, and fix a memory leak caused by unreleased OSS client connections.
This article details how JD’s Seckill platform expanded its product pool by up to tenfold through architectural redesign, JVM garbage‑collection tuning, dual‑cache updates, local LRU caching, and Bloom filter integration, achieving significant performance and stability gains for large‑scale flash‑sale events.
Apache Groovy 4.0.0 RC2 has been announced, featuring language enhancements such as new compilation behavior for operators and method naming, along with extensive upgrades to build, test, and runtime dependencies across the project.
This article provides an in‑depth, bottom‑up analysis of Java biased locking, covering its background, lock evolution, detailed mechanisms such as epoch, bulk rebias and revocation, practical JOL experiments, interactions with hashCode and wait, and the recent deprecation in modern JDK releases.
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.
Java's synchronized keyword provides mutual exclusion by using object monitors, offering class‑method, static‑method, and block locking patterns, while the JVM optimizes performance through biased, lightweight, and heavyweight lock strategies, making it essential knowledge for efficient concurrent programming.
This article outlines a comprehensive process for analyzing, diagnosing, and optimizing performance issues in production business systems, covering hardware, OS, database, middleware, JVM settings, code inefficiencies, and the role of monitoring tools like APM to pinpoint bottlenecks.
This comprehensive guide explains the JVM memory model, details each memory region, compares major garbage‑collection algorithms, and lists essential JVM tuning parameters for optimal Java performance.
This article outlines a comprehensive approach to diagnosing and optimizing performance problems in production business systems, covering common causes such as concurrency spikes, data growth, and environment changes, and detailing hardware, middleware, database, JVM, code-level analyses, monitoring tools, and APM strategies.
The article outlines a comprehensive process for diagnosing and optimizing performance problems in production business systems, covering causes such as high concurrency, data growth, hardware constraints, and detailing analysis of hardware, OS, database, middleware, JVM settings, code inefficiencies, and the role of monitoring and APM tools.
The 2021 JVM Ecosystem Report, based on responses from over 2,000 Java developers, reveals a shift from Java 8 to Java 11, widespread use of AdoptOpenJDK and Oracle builds, dominant IDEs like IntelliJ IDEA, Maven as the primary build system, and Spring as the leading framework in the Java ecosystem.
This comprehensive guide explores the inner workings of the Java Virtual Machine, covering memory regions, garbage‑collection algorithms, class‑file structure, bytecode instructions, class loading mechanisms, and method dispatch strategies, providing clear explanations and code examples for developers seeking a deeper understanding of JVM fundamentals.
This article details how JD.com’s flash‑sale system tackled rapid product‑pool growth by analyzing JVM memory issues, redesigning the architecture with double‑buffered updates, local LRU caching, system splitting, and Bloom‑filter integration, resulting in significant performance and stability improvements for large‑scale promotions.
This article details a two‑week effort to diagnose and resolve high CPU usage, server load, Hystrix circuit‑breaker inefficiencies, and Spring data‑binding exceptions in a Java backend service, resulting in doubled QPS capacity, stable circuit breaking under heavy traffic, and significant performance gains.
This article provides an in‑depth overview of the JVM runtime data structures, memory regions, garbage‑collection algorithms, GC roots, reference types, stop‑the‑world pauses, OopMap, safe points, stack‑overflow handling, class‑loading mechanisms, the parent‑delegation model, object stack allocation, and object layout, offering practical insights for Java developers preparing for interviews.
This article presents a thorough analysis of performance problems in production business systems, covering root causes such as concurrency, data growth, hardware limits, database and middleware bottlenecks, JVM tuning, code inefficiencies, and offers practical diagnostic steps, monitoring tools, and optimization strategies.
This article provides an in-depth exploration of Java's JVM memory architecture, garbage collection algorithms, class file structure, class loading process, bytecode execution, and method dispatch mechanisms, offering practical code examples and visual diagrams to help developers understand and optimize JVM performance.
This article explains the Java class file format, the composition of bytecode, how the JVM loads classes into memory, the various method‑invocation instructions, and tools such as asmtools and jhsdb that help developers inspect and analyze bytecode at runtime.
This comprehensive article explains the inner workings of the Java Virtual Machine, covering class file structure, class loaders, memory layout, garbage collection, execution engine, debugging via JPDA, hot deployment, hot swapping, and performance tuning techniques, providing practical code examples and configuration tips.
This comprehensive guide explains the JVM memory layout, class‑loading and object‑creation process, the parent‑delegation model, various garbage‑collection algorithms and collectors, GC roots, triggers for YGC and Full GC, and practical tuning parameters to improve Java application performance.
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.
This guide presents a detailed 2021 Java learning roadmap covering programming fundamentals, JVM internals, concurrency, data structures, algorithms, databases, development tools, backend frameworks, DevOps practices, and interview preparation, with curated resources and a practical study schedule to help learners secure a strong job offer.
This article provides a comprehensive, interview‑focused guide to the Java Virtual Machine, covering memory regions, garbage‑collection algorithms, reference types, GC roots, STW pauses, OopMap, safe points, stack overflow, class loading, the parent‑delegation model, stack allocation, and object layout, all with clear explanations and diagrams.
This article compiles a comprehensive list of frequently asked Java interview questions, covering topics such as the relationship between JDK/JRE/JVM, object creation methods, differences between == and equals, hashCode, String variants, synchronization mechanisms, lock implementations, collections, concurrency utilities, thread pools, and I/O models, providing concise explanations for each.
By replacing the default Parallel GC with a ParNew‑CMS collector, enlarging the Young generation, fixing Metaspace settings, and tuning CMS occupancy thresholds, the video service cut Young and Full GC pauses dramatically, lowered Full GC count by over 80%, and achieved more than 30% P99 latency reduction, with some APIs improving up to 80%.
This article explains how the JVM determines object liveness, describes reference counting and reachability analysis, lists GC Roots, and provides clear visual and code examples of the main garbage‑collection algorithms—mark‑sweep, copy, mark‑compact, and generational collection—highlighting their advantages, drawbacks, and typical use cases.
The article details a real‑world incident where a Java backend service suffered frequent full garbage collections, describes how the problematic instance was identified and isolated, and presents JVM tuning and MyBatis interceptor code changes that eliminated the issue while sharing key lessons learned.
This article analyzes how to estimate per‑second request concurrency for a billion‑daily‑traffic e‑commerce order system, calculates memory usage per order, examines JVM heap and GC behavior, and proposes configuration adjustments to reduce Full GC occurrences during large‑scale promotions.
This article explains the three‑color marking algorithm used by Java’s CMS and G1 garbage collectors, detailing the color semantics, algorithmic steps, common pitfalls such as floating garbage and miss‑marking, and the specific solutions each collector employs to minimize stop‑the‑world pauses and improve memory reclamation efficiency.
This article explains how variable sharing in multithreaded Java programs leads to thread‑unsafe behavior, explores the JVM memory model and stack frame structure, and demonstrates practical ways to achieve thread safety by keeping variables thread‑local or using proxy objects.
This article provides a comprehensive overview of the Java Virtual Machine, explaining its main purpose, memory regions, class‑loading mechanism, object creation process, memory allocation strategies, object layout, reference handling, garbage‑collection theories, algorithms, and common JVM tuning commands.
This article explains the architecture of the OpenJDK HotSpot JVM, covering bytecode execution, JIT compilation, garbage collection, ergonomic defaults, configuration options, their lifecycle, and practical tuning advice to help developers optimize Java applications for various environments.
The article explains that Java’s for(;;) infinite loop and while(true) are historically inherited from C, produce identical bytecode under javac, and their performance depends on the JVM implementation rather than the source syntax.
This article analyzes the main factors that contribute to Young Generation GC (YGC) latency in the JVM, covering safe‑point pauses, live object scanning and marking, object copying, GC log overhead, and OS activity, and offers practical tips for diagnosing and reducing pause times.
This article compiles a comprehensive list of frequently asked Java interview questions, covering topics such as JDK/JRE/JVM relationships, object creation methods, equality comparison, concurrency mechanisms, collections, thread pools, and I/O models, providing concise answers for quick reference.
This article introduces essential JVM performance monitoring and profiling tools—including jps, jstack, jmap, jhat, jstat, and hprof—explaining their syntax, options, and practical usage for diagnosing memory leaks, thread deadlocks, high CPU consumption, and other common Java production issues.
This guide walks Java developers through installing Groovy, using its .groovy files, manipulating lists, maps, conditionals, loops, and leveraging built‑in JsonBuilder and HTTPBuilder for JSON handling and HTTP requests, all with clear code examples.
This article provides a comprehensive overview of the Java Virtual Machine memory architecture, covering heap layout, allocation, tuning parameters, garbage collection, stack frames, method area, metaspace, native method stack, program counter, direct memory, and code cache, with practical code examples and diagnostics.
This article explains why manual jar management can cause class loading conflicts, shows quick IDE-based steps to reorder jars for a temporary fix, and dives into JVM classloader isolation, the parent‑delegation mechanism, and Tomcat's startup loading order to help developers debug and prevent such issues.
This article explains how Java objects are laid out in memory, compares the heap locations of fields and local variables, analyzes the byte size of a plain new Object() with and without compressed oops, demonstrates measurement using JOL, and reviews related heap regions and garbage‑collection concepts.
This article provides a thorough overview of Java fundamentals for interview preparation, covering JVM/JRE/JDK relationships, bytecode advantages, language features, OOP concepts, exception handling, garbage collection, reference types, and common pitfalls, supplemented with code examples and practical tips to strengthen core Java knowledge.
This guide explains the most common JVM startup flags for controlling garbage collection logging, heap sizing, class loading monitoring, and out‑of‑memory handling, providing sample outputs and detailed interpretations to help developers tune memory usage and diagnose performance issues in large Java applications.
The article recounts a staged rollout of the Maybach service on elastic cloud, details the timeline of successful and failing deployments, analyzes JVM metrics revealing excessive Metaspace usage that triggered continuous full garbage collections, and explains how this caused system‑wide timeouts and a half‑hour outage.
This article compiles a series of JVM interview questions covering heap partitioning, garbage‑collection algorithms, collector types, memory coordination, tuning strategies, and practical tooling such as jstat, jmap, and MAT, providing detailed explanations and command‑line examples for each topic.
This article provides a comprehensive overview of the Java Virtual Machine memory layout, covering the heap, metaspace, stack frames, program counter, direct memory, and code cache, along with practical tuning tips, demonstration code for heap OOM, and references for deeper study.
This article explains what large (huge) pages are, why they improve JVM performance, and provides step‑by‑step instructions for configuring Transparent Huge Pages and HugeTLB pages on Linux as well as enabling large pages on Windows, including verification techniques.
This article explains what a deadlock is in concurrent Java programs, discusses its impact on systems such as databases and the JVM, provides a guaranteed deadlock example with full source code, and walks through debugging steps to analyze and prevent such issues.
This article explains how Java threads map to OS kernel threads, details the Thread.State lifecycle, shows how to create threads by extending Thread or implementing Runnable, and walks through the JNI mechanism and HotSpot source code that drives thread startup and execution.
This article provides a comprehensive overview of the Java Virtual Machine memory layout, explaining each region such as the heap, metaspace, stack, program counter, direct memory and code cache, along with allocation strategies, tuning parameters, and practical OOM demonstrations.
This comprehensive guide covers Java platform basics, JVM/JRE/JDK relationships, bytecode advantages, new features since Java 8, core OOP principles, common interview questions, exception handling, garbage collection, reference types, and practical code examples to solidify your Java expertise.
This article provides a comprehensive overview of Java fundamentals, covering the relationship between JVM, JRE and JDK, the execution model, bytecode advantages, Java 8 language enhancements, core OOP principles, exception handling, reference types, and practical code examples for developers.
This article provides an extensive overview of Java fundamentals, covering the JVM/JRE/JDK relationship, bytecode and JIT compilation, core language features introduced in Java 8, basic syntax differences, data types, OOP principles, SOLID design, exception handling, reference types, and string manipulation classes.
This article explains how Java objects are stored in memory, covering the object header, instance data, alignment padding, lock states, pointer compression, and field reordering, and demonstrates how to inspect these structures using the OpenJDK JOL tool with practical code examples.
This article presents a step‑by‑step methodology for troubleshooting high RSS memory consumption in Java applications, covering heap size assessment, ARENA region analysis, native memory tracking, off‑heap memory checks, and automation tools to streamline the entire diagnostic process.
This article examines the various causes of Java OutOfMemoryError, demonstrating heap overflow, stack overflow, metaspace exhaustion, and direct memory exhaustion through practical code examples, and explains how to diagnose and differentiate memory leaks from genuine memory overuse using JVM tools.
Following the US Supreme Court's decision that Google's use of Java APIs in Android is lawful, Microsoft announced the preview of its Microsoft Build of OpenJDK, a free, long‑term‑support Java distribution aimed at Azure users and developers.
This article records an interview experience, presenting core questions on Java memory allocation, JVM parameters, Spark and MapReduce execution models, data skew causes and mitigation, real‑time framework scheduling, and system design for massive task scheduling, followed by analysis and learning recommendations.
This article introduces the most frequently used JVM startup parameters, explains their effects on garbage collection, heap configuration, class loading monitoring, and out‑of‑memory handling, and provides example outputs to help developers tune Java applications for large‑scale projects.
This guide explains how to lower the high memory usage of Spring Cloud applications on low‑end machines by adjusting per‑project JVM options in IntelliJ IDEA, detailing the necessary -Xmx, -Xms, -Xmn and -Xss parameters and showing the resulting performance improvement.
This article explains the theoretical and practical limits of Java String length, detailing how strings are stored as char arrays, the impact of the JVM constant‑pool specification (u2 index limit of 65534), and how runtime concatenation can exceed compile‑time restrictions.
Through a multithreaded test program, this article explores whether Java’s 64‑bit long and double types are accessed atomically on 32‑bit and 64‑bit JVMs, explains the JVM memory model rules, and shows how volatility and hardware affect atomicity.
This article explains the Java heap structure, generational layouts in JDK 1.7 and 1.8, the G1 collector's region-based approach, and detailed object allocation rules including Eden placement, large object handling, promotion thresholds, and space allocation guarantees.
This article explains the purpose of learning the JVM memory layout, describes each runtime data area—including program counter, VM stack, native method stack, heap, and method area—highlights thread‑private versus shared regions, and provides code samples that trigger StackOverflowError and OutOfMemoryError across different JDK versions.
This article explains why code optimization is crucial for preventing unexpected runtime errors, outlines the main goals of reducing code size and improving execution efficiency, and provides a comprehensive list of practical Java optimization techniques—from using final modifiers and reusing objects to proper resource handling and avoiding common pitfalls—complete with code examples and performance explanations.
This article outlines key backend performance optimization techniques—including code refactoring, database tuning, caching strategies, asynchronous processing, NoSQL usage, multithreading, and JVM tuning—to help developers build faster, more reliable services.
The article compares Java’s mature, generational garbage collector—using mark‑copy for young objects, mark‑sweep/compact for old, with sophisticated write barriers and fragmentation handling—to Go’s non‑generational, concurrent tri‑color mark‑sweep collector that relies on a span‑based memory pool, TCMalloc optimizations, and simpler root selection.
The article shares the author’s experience reading the third edition of "Understanding the JVM," focusing on JVM memory management, garbage‑collection algorithms, tuning strategies, and practical tools, while providing concise summaries of each book section and actionable advice for Java performance optimization.
This article walks through a production JVM memory‑leak incident, detailing how a static LRU cache built on LinkedHashMap caused unreclaimed objects, the concurrency pitfalls of its design, and practical steps to diagnose and fix such leaks in Java backend systems.
The 2021 JVM Ecosystem Report, based on responses from over 2,000 Java developers, reveals a steady migration from Java 8 to Java 11, widespread use of AdoptOpenJDK, dominant IDEs like IntelliJ IDEA, Maven as the primary build system, and Spring as the leading framework in the Java ecosystem.
The article explains Java’s automatic memory management, detailing JVM memory regions, object liveness via reachability analysis, allocation strategies, and the main garbage‑collection algorithms—Mark‑Sweep, Mark‑Copy, Mark‑Compact—and compares HotSpot collectors such as Serial, Parallel, CMS and G1, guiding developers to choose the best fit for their workloads.
According to Snyk’s 2021 JVM Ecosystem Report, Java 11 now powers 61.5% of production environments, while Java 8 usage declines, and the Java community overwhelmingly favors Spring, IntelliJ IDEA, Maven, and a growing mix of IDEs and languages like Kotlin.
The article provides a comprehensive overview of Java garbage‑collection algorithms, JVM memory regions, object reachability analysis, the semantics of volatile, synchronized and ReentrantLock, thread‑pool creation and operation, deadlock examples, distributed‑lock strategies, and related tooling such as JUC utilities and Git conflict handling.
The article explains how intermittent latency spikes (jitter) in a high‑throughput service can be triggered when the JVM’s Just‑In‑Time compiler activates, detailing interpreter vs. JIT, C1/C2 tiered compilation, hot‑spot detection thresholds and compilation stages, and recommends pre‑warming code, disabling tiered compilation, or tuning thresholds and JVM flags to eliminate jitter.
This article presents a structured method for diagnosing high RSS memory consumption in Java services, detailing step‑by‑step analysis of heap, off‑heap, and native memory, recommending specific commands and tools, and proposing an automated shell‑based workflow to streamline the troubleshooting process.
This article explains Java’s constant pool architecture, the role of the String pool across JDK versions, demonstrates how String.intern() works with code examples, and shows how interning can dramatically reduce memory usage while also highlighting potential pitfalls.
This article describes how a Java backend service suffered high CPU usage and load, how the team diagnosed the problems with jtop and thread stacks, optimized JSON/Bean processing, re‑engineered Hystrix circuit‑breaker settings, reduced logging overhead, and fixed Spring data‑binding exceptions to double the QPS and achieve stable recovery after traffic spikes.
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.
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.
This article explains how to optimize Spring Boot's embedded Tomcat settings, tune JVM parameters, configure remote debugging in IDEA, and connect to JVM tools like JConsole and JVisualVM remotely, while also providing practical code snippets and deployment tips for backend services.
This article explains how to use built‑in JVM tools such as jps, jstack, jmap, jstat and hprof to diagnose memory leaks, OutOfMemoryError, thread deadlocks, lock contention and high CPU usage in enterprise Java applications, providing command syntax, examples and interpretation of output.
