This article explains the JVM memory layout, covering the heap (including Xms/Xmx tuning, Young/Old generations, and garbage collection), Metaspace versus PermGen, the thread‑private JVM stack and native method stack, and the program counter register, with practical code examples.
This article examines the inner workings of Java’s synchronized keyword by analyzing HotSpot 1.8 source code, revealing how lightweight, heavyweight, biased, and adaptive spin locks operate, how lock inflation occurs, and how the JVM manages monitor objects, CAS operations, and thread queues to implement synchronization.
This article explains the JVM memory layout, covering the heap (young and old generations), Metaspace, virtual machine stacks, native method stacks, and the program‑counter register, while describing their roles, configuration parameters and how they interact during garbage collection and method execution.
This article demystifies the JVM’s runtime data areas and illustrates, with a simple Java example and animation, how a program’s bytecode is executed—from the program counter and stack frames to heap allocation and garbage collection—providing a clear, step‑by‑step view of Java execution.
This article demonstrates how to configure Spring Boot for multiple environments, retrieve custom parameters, package and run the application, modify startup settings via system variables or command‑line arguments, and explains the priority and detailed JVM options for optimizing a Spring Boot service.
This guide explains why graceful shutdown matters for Java services, describes the three JVM termination scenarios, demonstrates normal, abnormal, and forced shutdowns with code, and provides best‑practice rules and real‑world examples such as Spring integration and custom signal handling.
This article explains the JVM memory layout, covering the heap area, its configurable size and generational structure, the Metaspace replacement for PermGen, the thread‑private virtual machine stack and native method stack, as well as the program counter register and related garbage‑collection behavior.
The article explores how Java has survived massive industry shifts through a vibrant community, extensive open‑source frameworks, continual language evolution, and emerging opportunities like WebAssembly, illustrating why it stays a cornerstone of enterprise and creative software development.
This article explains Java's class loading mechanism, detailing memory structures, the roles of the bootstrap, extension, and application class loaders, the parent delegation model, custom class loaders, and related JVM phases such as loading, linking, and initialization, with code examples throughout.
This article explores the complete lifecycle of graceful shutdown for Java server applications, detailing how operating‑system signals, JVM shutdown hooks, and framework‑level mechanisms in Spring, Dubbo, and Netty collaborate to safely stop services while preserving in‑flight requests and resources.
This article provides a comprehensive overview of the JVM's memory layout, class loading subsystem, classloader categories, the parent‑delegation model, and custom classloader implementation, illustrating each concept with detailed explanations and code examples for Java developers.
This article explains the Java constant pool concept, details how the String constant pool works in different JDK versions, demonstrates the effects of String.intern() with code examples, and discusses practical applications and pitfalls of using intern for memory optimization and synchronization.
This article explains how the Java Virtual Machine achieves write‑once‑run‑anywhere by abstracting platform differences, then details the JVM’s internal components—including the class‑loader subsystem, runtime data areas such as heap, stack, method area, and program counter—followed by code examples and analysis of object layout, pointer compression, and memory allocation strategies.
This article explains the JVM memory architecture, covering the heap (young and old generations, Eden and Survivor spaces), Metaspace, virtual machine stacks, native method stacks, and the program counter register, while also illustrating key JVM parameters and bytecode execution with examples.
Starting from mysterious Java Agent errors in Alibaba Cloud environments, this article traces the failure through the JVM’s Instrumentation.appendToSystemClassLoaderSearch call, examines glibc’s stat and iconv conversions, reveals thread‑local storage issues, and presents concrete fixes using pthread TLS and proxy wrappers.
This article provides a comprehensive overview of JVM memory layout, explains major garbage‑collection algorithms and collectors, details how different memory regions cooperate, and offers practical tuning steps and tool usage for diagnosing GC issues in Java applications.
This article simulates a Baidu interview to explain the underlying implementation of Java’s synchronized keyword, covering monitorenter/monitorexit bytecode, object header Mark Word, lock states, lock escalation from biased to heavyweight, and the role of CAS in lock acquisition and release.
The article details a real‑world case where JVM C2 CompilerThread CPU spikes during service startup caused request timeouts and GC pressure, explains how profiling identified the JIT compilation as the root cause, and describes a warm‑up replay strategy that pre‑compiles hotspot code to eliminate the spikes and stabilize deployments.
This page provides an extensive curated list of Groovy tutorials covering introductions, environment setup, syntax basics, GString, keywords, traversal, regular expressions, integration with Java, Gradle, JMeter, operator overloading, closures, reflection, performance comparisons, and advanced scripting techniques for backend development.
This article details how a Java Spring Boot microservice's response time was reduced from 5‑6 seconds to under one second by applying gzip compression, parallel data fetching, short‑lived caching, MySQL index tuning, and JVM G1 garbage‑collector adjustments.
This guide compiles fifty practical Java performance recommendations—ranging from judicious use of singletons and static variables to efficient collection handling, memory management, and low‑level optimizations like bit‑shifts and System.arraycopy—each illustrated with concise explanations and code snippets to help developers write faster, leaner Java code.
This article details Meituan's internal Sonic IDEA plugin, explaining hot‑deployment concepts, why they matter, the technical challenges, and Sonic's architecture—including agents, instrumentation, class reloading, Spring Bean/XML/MyBatis reloads, and real‑world deployment experience—showing how code changes can become effective in seconds instead of minutes.
The article details a step‑by‑step investigation of a SpringBoot application that repeatedly triggered high swap usage, describing how JVM parameters, native memory tracking, gperftools, strace, and custom memory allocators were used to pinpoint and resolve off‑heap memory leaks caused by the Inflater implementation and glibc memory pools.
This article explains how Java creates objects with the new operator, details the JVM's stack and heap memory model, describes class loading and the role of Class objects, and compares newInstance with new, providing code examples and visual diagrams for deeper comprehension.
ZGC (Z Garbage Collector) is a scalable, low‑latency collector introduced in JDK 11, featuring sub‑millisecond pause times, region‑based memory layout, colored pointers, NUMA awareness, and concurrent phases, with detailed explanations of its architecture, parameters, triggers, and log analysis.
ZGC, introduced in JDK 11 and stabilized in JDK 15, is a low‑latency, region‑based, concurrent garbage collector that aims for sub‑millisecond pause times regardless of heap size, leveraging colored pointers, NUMA awareness, multi‑mapping, and read barriers to achieve efficient memory reclamation.
This article details how JD.com tackled rapid growth of its flash‑sale product pool by analyzing JVM GC bottlenecks, redesigning the system architecture, introducing dual‑cache bucket updates, local LRU caching, Bloom filters, and service separation, ultimately achieving significant performance and stability improvements for large‑scale promotions.
An in‑depth analysis reveals how Groovy’s implicit getter feature and method‑resolution rules cause a static method call to be intercepted by a subclass’s getTest method, leading to unexpected output and thread locking during performance testing.
This article explains why the assumption that java.lang.Object is an instance of java.lang.Class is wrong, how Class actually extends Object, and how the JVM resolves the chicken‑egg problem through a bootstrap process that initializes core types before normal execution.
This article provides a theoretical overview of seven major Java performance optimization techniques—including code reuse, computation parallelism, asynchronous processing, lazy loading, result set reduction, resource conflict handling, and JVM tuning—offering readers a comprehensive framework to understand and improve application efficiency.
This article presents a theoretical overview of seven major Java performance‑optimization directions—including reuse, parallel execution, async conversion, result‑set trimming, resource‑conflict handling, algorithm tuning, and JVM tuning—explaining their principles, typical techniques, and practical considerations for developers.
This article explains the complete lifecycle of Java object creation, covering the JVM's handling of the new bytecode, class loading, memory allocation strategies such as pointer bumping and free lists, object header structure, layout, and tools for inspecting object memory.
The article shows how to overcome extensibility limits in a Java list‑management system by creating a custom DynamicClassLoader that loads encrypted .class files at runtime, explains Java’s class‑loading stages, fixes a Tomcat deployment issue via proper parent delegation, and demonstrates dynamic invocation of new encryption modules without code changes.
This guide highlights the most influential Java books—from core language fundamentals and JVM internals to concurrency and effective coding practices—explaining why each title is vital for building a solid backend development skill set.
This article explains how the JVM loads and links class files, describes the five runtime data areas—including the Method Area, Heap, JVM Stacks, Program Counter, and Native Method Stack—and details the class‑loader hierarchy and the parent‑delegation model used during class loading.
This article explains Java's String length limits, detailing how the underlying char[] array, int return type, and JVM constant‑pool specifications together define both the theoretical 2^31‑1 character maximum and the compile‑time literal limit of 65,534 characters.
This article outlines seven fundamental Java performance‑optimization directions—ranging from code reuse and parallel execution to JVM tuning—providing a theoretical framework that helps developers understand how to balance resource usage, reduce latency, and improve overall system efficiency.
Many interviewees expect the Java expression ‘a == b’ to be false and ‘c == d’ true when using Integer objects, but due to the Integer cache range and JVM settings, both comparisons can actually return true, a nuance explained through source code analysis and cache configuration.
This article demonstrates how to use the JDK’s native command‑line and graphical utilities—such as jps, jinfo, jvisualvm, jconsole, jstat, jstack and jcmd—to observe JVM metrics, troubleshoot memory and thread issues, and verify JVM parameters in Java applications.
This article explains how Java objects are laid out in the JVM heap, why fields are reordered and padded for alignment, how false sharing degrades performance, and how the @Contended annotation and compressed oops help mitigate these issues, all backed by detailed diagrams and code examples.
The author describes a high‑QPS Java web service, analyzes its GC behavior using jstat and gceasy, applies JVM parameter adjustments such as enlarging the young generation, tweaking MaxTenuringThreshold and disabling biased locking, and achieves roughly a 15% overall performance gain with improved GC throughput.
This article walks through installing Arthas, selecting Java processes, and using core commands such as session, exit, dashboard, thread, jvm, trace, and monitor to diagnose, profile, and troubleshoot Java applications in production environments, complete with command examples and output snippets.
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.
