This article introduces core Java concepts, comparing procedural and object‑oriented thinking, explains what Java is, clarifies the relationships among JVM, JRE, and JDK, describes bytecode advantages, contrasts Java with C++, and details the three pillars of OOP—encapsulation, inheritance, and polymorphism—plus inner classes.
This article explains why the results of comparing strings with the == operator differ when using String.intern() in Java, illustrating the behavior with code examples, bytecode analysis, and JVM constant pool details to clarify true versus false outcomes.
This article explains why Java String objects are immutable, how the JVM’s string constant pool reuses instances, the role of the final keyword and char[] storage, and demonstrates that all mutating operations actually create new String objects rather than altering the original.
This article compiles 30 essential Java interview questions covering OOP fundamentals, collections, concurrency, JVM internals, Spring framework, and performance optimization, providing concise explanations and key concepts to help backend developers prepare effectively for technical interviews.
This article explains JVM escape analysis, categorizes object escape levels, and shows how stack allocation, scalar replacement, and synchronization elimination can reduce heap usage and improve performance, including practical code examples and JVM flags.
This article explains Java's String length limitations, detailing how strings are stored as char arrays, the int‑based length method, the JVM class‑file constant pool constraints (u2 index max 65535, effectively 65534), and demonstrates practical experiments confirming these limits.
This article explains the causes of various Java OutOfMemoryError scenarios—including heap, stack, metaspace, and direct memory overflow—provides diagnostic tools, shows reproducible code examples, and offers practical solutions such as adjusting JVM parameters and optimizing code to prevent memory exhaustion.
This article shares a detailed personal account of multiple Java backend interview rounds, covering technical topics such as JVM, design patterns, distributed locks, Redis, and system design, while also offering practical advice on preparation, self‑presentation, career planning, and interview mindset.
Java's String type has both theoretical and practical length limits: while the underlying char[] array can hold up to 2^31‑1 characters (~4 GB) due to int indexing, the JVM constant‑pool restricts literal strings to a maximum of 65 534 characters, as explained with code examples and spec excerpts.
This article walks through the complete troubleshooting and performance‑tuning process for a high‑concurrency SSM‑based e‑commerce system, covering problem identification, root‑cause analysis, JVM, Tomcat, Redis and MySQL optimizations, traffic shaping, and the resulting stability improvements.
This article uses the Chinese Spring Festival story to explain Java's heap structure, young and old generations, large‑object allocation, and how excessive memory consumption leads to heap‑space OOM and stop‑the‑world garbage collection, providing code examples and practical mitigation tips.
Memory leaks, caused by unreleased dynamic allocations, can accumulate and lead to memory overflow, severely degrading performance or crashing applications; this article explains leak definitions, causes, classifications (persistent, intermittent, one‑time, implicit), overflow reasons, and practical mitigation steps such as proper allocation, deallocation, and JVM tuning.
The article walks through a real‑world Java service outage caused by CPU saturation, details a systematic five‑step investigation, reveals a memory leak in BouncyCastleProvider objects within JceSecurity, and explains how converting the provider to a static singleton resolved the issue.
The author reflects on four pivotal experiences—from handling billion‑scale system outages to deep‑diving into JVM internals—that dramatically boosted his coding skills, emphasizing practical learning, robust code, and continuous self‑challenge for backend engineers.
This article details a systematic investigation of various backend performance problems—including CMS GC delays, biased‑lock revocation, Netty worker thread blocking, and log‑framework overhead—provides root‑cause analysis, JVM tuning parameters, and practical recommendations to mitigate latency spikes in production services.
Even though many joke that simply increasing JVM heap solves performance issues, this article explains why blind memory expansion often worsens latency in high‑concurrency scenarios and presents concrete tuning strategies such as adjusting young generation size, reducing stack memory, and monitoring GC metrics.
This article compiles essential JVM interview topics, covering ClassLoader mechanisms, Java memory layout, garbage collection concepts and algorithms, as well as practical performance tuning techniques, providing links to detailed resources and common interview questions for each area.
This article explains how the Java Virtual Machine loads .class files into memory, detailing the three-stage process of loading, linking (verification, preparation, resolution), and initialization, while also covering array loading, custom class loaders, and common pitfalls such as deprecated APIs and verification options.
This article explains how to diagnose and optimize Flink jobs by first examining metrics, then checking resource allocation, analyzing throughput and back‑pressure, and finally tuning JVM settings, while providing concrete configuration examples and practical tips for big‑data practitioners.
The article shares eight concrete production incidents—from JVM Full GC spikes and memory leaks to cache avalanches, deadlocks, DNS hijacking and bandwidth exhaustion—detailing their root causes, step‑by‑step diagnostics, code snippets, monitoring tricks and practical remediation measures for engineers.
This article explains Java's parent delegation class‑loading model, describes the four built‑in class loaders, details why delegation is needed, shows the loadClass implementation, and discusses how and why the mechanism can be overridden in frameworks such as JDBC, Tomcat, OSGi, and the Java 9 module system.
The author recounts four pivotal experiences—from handling a billion‑scale transaction system and joining Taobao’s ad‑hoc “firefighter” squad, to rewriting a communication framework and deep‑diving into JVM internals—illustrating how real‑world challenges and collaborative learning dramatically sharpened his coding and system‑reliability skills.
Yidun’s public-opinion monitoring platform transforms massive raw web data into a unified format by separating dynamic Groovy-script-driven cleaning from static processing, achieving real-time source integration, high throughput, scalability, and high availability while addressing format diversity, team coordination, and performance-flexibility trade-offs.
This comprehensive guide walks through the Java Virtual Machine's runtime data areas, memory model, heap layout, garbage‑collection mechanisms, HotSpot internals, performance tuning flags, and class‑loading process, providing developers with the essential knowledge to optimize Java applications.
This article outlines a step‑by‑step approach for identifying root causes of performance bottlenecks in production business systems, covering common scenarios such as high concurrency, data growth, hardware limits, database and middleware tuning, code inefficiencies, and the role of monitoring and APM tools.
This article details a step‑by‑step performance tuning journey for a Java‑based SOA service, covering thread‑pool redesign, memory‑allocation adjustments, and JIT compilation tweaks that together lifted QPM by nearly 40% and overall system throughput by about 50%.
This comprehensive guide explains the JVM memory layout, object allocation, garbage collection mechanisms such as mark‑sweep, copying, and mark‑compact, details GC roots, reference types, collector types, tuning parameters, and related Java performance tools, providing practical code examples and diagrams.
This article summarizes a year‑long performance tuning of an ELK logging system, analyzing bottlenecks such as write thread pool saturation, JVM heap and GC settings, refresh intervals, translog durability, merge threads, shard and replica counts, and provides concrete configuration changes that reduced latency, eliminated data loss, and stabilized node resource usage.
This article provides a detailed, practical guide to optimizing HBase in production, covering table pre‑splitting, RowKey design, JVM memory and GC settings, MSLAB and BucketCache configuration, read‑side client and server tuning, write‑side strategies, and additional tips such as compression and scan caching.
This article introduces JMH, the Java Microbenchmark Harness, explains why traditional main‑method benchmarks are unreliable, and provides step‑by‑step instructions, code examples, and best‑practice annotations for accurately measuring method‑level performance in Java applications.
This article details a systematic experiment that compares default, modest, balanced, and aggressive JVM memory configurations for IntelliJ IDEA, measuring startup time, project load speed, and garbage‑collection behavior on a large monolith and micro‑service projects, and concludes with practical tuning recommendations.
This article investigates how different IntelliJ IDEA memory configurations affect IDE speed and responsiveness by testing default, large, balanced, and sophisticated settings on a MacBook Pro with a monolithic Java project and microservices, measuring startup times, project loading, and JVM garbage collection using jstat.
This article explains the different types of Java garbage collectors, focuses on the G1 (Garbage‑First) collector’s region‑based architecture, key data structures and algorithms such as TLAB, PLAB, CSet, Card Table, RSet, and SATB, and provides detailed log analysis and tuning recommendations to improve pause times and throughput.
This article explains the three JVM shutdown methods, how to use ShutdownHook and custom SignalHandler for cleanup, and outlines a step‑by‑step graceful restart process using kill -12, kill -15, and kill -9 signals, with sample scripts and references.
This article explains why jar version conflicts cause runtime errors in Java, introduces class isolation as a solution, and provides step‑by‑step implementations of custom ClassLoaders using both findClass and loadClass overrides, complete with code examples and execution results.
This article explains the role of Java's Just‑In‑Time compiler, how HotSpot combines interpretation and compilation, the mechanisms for hotspot detection, the differences between C1 and C2 compilers, performance testing across modes, and the key optimization techniques that make JIT‑generated code faster.
This article explains the JVM garbage collection mechanism, covering which memory areas are collected, how object reachability is determined, the main GC algorithms, generational collection theory, and JVM heap layout, providing essential knowledge for Java performance tuning.
This article provides a comprehensive overview of the Java Virtual Machine, covering its runtime data areas, the Java Memory Model, heap organization, garbage‑collection algorithms, HotSpot implementation details, JVM tuning parameters, and the class‑loading mechanism.
Tracing a large method with Arthas caused a Metaspace OOM because constant‑pool rewrites inflated the Non‑Class space, each rewrite copying a massive StackMapTable, but preserving the original constant‑pool layout in Arthas stops the growth, and exposing off‑heap metrics aids production monitoring.
This article provides a comprehensive, English‑language walkthrough of Java Serviceability Agent (SA), covering how to obtain and analyze JVM internal structures, the memory model and Linux process layout, the oop/klass split, JIT compilation mechanics, and the implementation of tools such as jmap and jstack, all illustrated with code snippets and diagrams.
Java’s String length is bounded by both the int‑based array limit (≈2 billion characters) and a JVM compile‑time restriction of 65,534 characters due to the constant‑pool’s u2 index, a nuance explained through source code examples, JVM spec excerpts, and a practical experiment.
This article explains how Java objects store behavior and attributes, describes the JVM method area where method bytecode resides, and demonstrates practical dynamic tracing techniques using java.lang.instrument.Instrumentation, BTrace scripts, and the Arthas diagnostic tool.
This article details a complete end‑to‑end high‑concurrency tuning process for a Java SSM monolithic e‑commerce system, covering problem identification, root‑cause analysis, a series of JVM, Tomcat, Redis and JDBC optimizations, horizontal scaling, code refactoring, and the resulting stability improvements.
This article demystifies the common advice of assigning null to unused objects by showing how Java's runtime stack and reachability analysis affect garbage collection, using concrete code examples, GC logs, and stack‑slot reuse to explain when null‑assignment actually helps reclaim memory.
This article outlines a comprehensive process for identifying root causes of performance bottlenecks in production business systems, covering hardware, database, middleware, JVM settings, code inefficiencies, and monitoring tools, and provides practical optimization techniques for each layer.
This article explains how Java stores strings using a char array, the theoretical maximum length of 2^31‑1 characters, and why the JVM limits string literals to 65,534 characters due to constant‑pool u2 indexing, illustrated with code examples and a practical experiment.
This article explains why Java strings have length limits, detailing the char[] storage, the int‑based array size ceiling, the JVM constant‑pool u2 restriction of 65535 bytes, and demonstrates a compile‑time experiment building a 65,534‑character literal to illustrate the practical impact.
This article explains how Java stores strings using a char array, the theoretical 4 GB limit from the int type, and the JVM’s compile‑time constant‑pool restriction that caps literal strings at 65,534 characters, plus a practical experiment confirming the limit.
This article explains how Java initializes static variables and static blocks, demonstrates the order with ThreadLocal hash‑code generation examples, analyzes class loading rules, and summarizes the impact on object instantiation and inheritance hierarchies.
This article explains the purpose and required signature of Java's main method, detailing why it must be public, static, return void, and accept a String[] argument, and describes how the JVM launches and invokes this entry point.
This article explains how Java strings are stored, the theoretical 2^31‑1 character limit imposed by the underlying char[] array, and the practical 65534‑character limit enforced by the JVM constant‑pool specification, illustrated with code examples and a small experiment.
This article presents ten challenging Java interview questions covering method overloading, object comparison, garbage collection, parameter passing, string creation, floating‑point precision, static method behavior, double comparison, try‑catch‑finally execution, and main method overloading, each followed by a concise explanation of the correct answer.
This article examines the evolution and classification of HotSpot JVM garbage collectors, explaining the performance triangle of heap usage, throughput and pause time, and detailing generational, region‑based, and low‑latency collectors such as G1, Shenandoah, and ZGC with their design principles and benchmark results.
This guide explains Java HotSpot CMS garbage collection fundamentals, common problem scenarios like space shock and premature promotion, systematic root‑cause analysis using logs and tools, and practical optimization tactics such as stabilizing heap size, tuning CMS flags, monitoring off‑heap memory, and migrating to newer collectors.
This article explains the JVM's stack‑frame structure, local variable tables, operand stacks, dynamic linking, and method return addresses, then demonstrates method call execution with sample Java code and bytecode, and analyzes how the JVM resolves overloaded and overridden methods through static and dynamic dispatch.
The article explains how a high‑frequency trading firm evaluated Java versus C++ for ultra‑low‑latency trading, discusses the challenges of JVM JIT compilation and garbage‑collection pauses, and shows how Azul Zing’s C4 collector delivers near‑C++ latency while preserving Java’s development productivity.
This article explores the underlying principles of Java Virtual Machine garbage collection, detailing core concepts, classic algorithms, generational and incremental improvements, and the role of read/write barriers, helping developers grasp why mastering GC is a fundamental skill for high‑performance Java programming.
The article explores whether Java private methods are automatically treated as final by examining IDE warnings, quoting "Thinking in Java," compiling sample code, and analyzing the resulting bytecode with a viewer to reveal the actual access flags and their implications.
This article explains how Tencent's self‑developed KonaJDK underpins cloud Java services, enhances micro‑service monitoring, adds national cryptography support, optimizes large‑heap tools like jmap, and delivers performance gains for big‑data workloads, while contributing key features back to the OpenJDK community.
This article explains common JVM problems such as OutOfMemoryError, memory leaks, and thread deadlocks, then introduces core monitoring tools—jps, jstack, jmap/jhat, jstat, and hprof—detailing their syntax, options, and practical examples to help Java developers diagnose and tune production applications.
This article walks through a JVM crash that occurs during garbage collection, explains how to use the SA tool CLHSDB to locate the offending object, discusses the role of compressed oops and MemberName vmtarget, and provides concrete fixes such as adjusting field writes or disabling pointer compression.
This article explains how the JVM C1 compiler uses value numbering and global value numbering to merge identical computations, detailing hash calculation, ValueMapArray structures, control‑flow analysis, kill scenarios, and code transformation techniques for effective optimization.
Java’s JIT compilation transforms bytecode into optimized native code at runtime using tiered C1 and C2 compilers—or Graal—to apply SSA, inlining, escape analysis, loop unrolling, and other optimizations, while profiling‑driven thresholds and tuning flags let developers balance startup speed, peak throughput, and latency.
This article explains Java's explicit null checks, introduces the JVM's implicit null check mechanism via ImplicitNullCheckStub, and details how the C1 and C2 compilers perform null‑check elimination using data‑flow analysis and SSA, highlighting performance implications and optimization strategies.
A detailed investigation of a slow Elasticsearch cluster revealed that massive Stop‑The‑World (STW) safepoint pauses caused by a buggy ARM‑based JDK version were the root cause, and switching to a proper Kona JDK eliminated the frequent ForceSafepoint interruptions and restored performance.
The article details a real‑world investigation of a Java HTTP service that experienced a sudden QPS increase and response‑time spikes, tracing the issue through database queries, local method latency, CPU load, frequent ParNew GCs, and large response payloads, and presents concrete remediation steps.
This article provides a comprehensive analysis of the HotSpot JVM implementation of the synchronized keyword, covering object header layout, the three lock states (biased, lightweight, heavyweight), their acquisition and release processes, bytecode differences, and practical code examples to help readers understand Java concurrency internals.
This article investigates whether Java int primitives are cached during execution, detailing JVM stack allocation, the specific bytecode instructions (iconst, bipush, sipush, ldc) used for different int ranges, and how local variable tables and operand stacks interact, illustrated with code and bytecode examples.
This article provides a comprehensive overview of the Java Virtual Machine memory layout, explaining the roles and allocation strategies of the heap, metaspace, stack frames, program counter, direct memory, and code cache, and includes practical code examples for heap tuning and OOM demonstration.
This article explores why Java’s entry‑point main method must be declared public, static, and void, covering JVM requirements, the role of static loading, accessibility, and the rationale for its void return type, while also noting related modifiers and common misconceptions.
Although StringBuilder and StringBuffer share similar APIs, StringBuilder lacks thread safety because its append method updates shared fields without synchronization, leading to race conditions that can corrupt the internal char array and cause ArrayIndexOutOfBoundsException, as demonstrated by a multithreaded test example.
This tutorial explains the three main categories of JVM parameters—standard, X, and XX—demonstrates how to view, modify, and verify them using command‑line tools such as java, jps, and jinfo, and provides step‑by‑step hands‑on labs for each type.
This article demystifies the JVM’s memory architecture and execution engine, walking through class loading, the runtime data areas, JIT versus interpreter, and native interactions, complemented by clear diagrams to help developers understand how Java manages memory and executes code.
This article provides a comprehensive analysis of the HotSpot JVM implementation of the synchronized keyword, explaining object headers, biased, lightweight, and heavyweight locks, their acquisition, release, and upgrade processes, and includes detailed source code and bytecode examples.
This article explains the definitions of JVM -Xms and -Xmx, how heap memory grows and shrinks, the impact on garbage collection, and why configuring both parameters to the same value can improve performance and stability in production environments while noting potential drawbacks.
This article provides a comprehensive overview of the Java Virtual Machine runtime data area, detailing each memory partition—including the JVM stack, native method stack, heap, method area, and program counter—and explains the concept and usage of direct memory.
This article provides a comprehensive overview of the Java Virtual Machine memory model, detailing each runtime data area—including the heap, stacks, method area, program counter, and direct memory—and explains their purposes and interactions within Java applications.
Learn how to accelerate Java applications on Google Cloud Run by minimizing container image size, leveraging container-aware JVM settings, reducing thread usage, and applying Spring Boot-specific tweaks such as layered JARs, lazy initialization, and avoiding background tasks to cut startup latency and memory consumption.
This article explains that Java fundamentally uses pass‑by‑value for method parameters, distinguishing between primitive value types stored on the stack and reference types whose references are passed, and demonstrates the behavior with code examples that clarify why apparent reference passing is actually passing a copy of the reference.
This article explains how Java's String.intern method interacts with the string constant pool, detailing the differences between JDK6, JDK7, and JDK8 implementations, and walks through multiple code examples that show why strings that were originally unequal become identical after interning.
This article explains the functions and storage locations of Java's runtime constant pool, string constant pool, and static constant pool across different JDK versions, illustrating JVM memory layout, constant pool structures, and how they evolve from PermGen to Metaspace.
This article details a step‑by‑step performance tuning process for an SSM‑based e‑commerce system experiencing severe CPU, memory, Redis, and JDBC issues during flash‑sale spikes, covering root‑cause analysis, JVM and Tomcat optimizations, connection‑pool adjustments, code refactoring, and the resulting stability improvements.
The article explains how Log4j2 can cause thread blocking under heavy exceptions due to class‑loading locks, describes the JVM's reflection optimization mechanism, shows how to verify it with sample code, and outlines ways to disable or tune the optimization using system properties.
The article shares the author's recent move to Xi'an, discusses the local job market, and provides detailed interview questions and answers on Java backend topics such as Redis replication, Kafka performance, MySQL transactions, and JVM garbage collection to help job seekers prepare effectively.
This article explains the JVM storage mechanisms for primitive and wrapper types, the Integer cache range, autoboxing/unboxing behavior, and why certain Integer comparisons using ‘==’ return true or false, providing code examples and detailed analysis.
This article explains the distinction between Java's RUNNABLE thread state and the operating‑system concepts of ready, running, and waiting, covering JVM‑level definitions, I/O blocking behavior, time‑slice scheduling, and includes concrete code examples to illustrate how blocked I/O still appears as RUNNABLE.
This article dissects the Java String creation process, explaining how the constant pool and heap interact, why new String("abc") can generate one or two objects, and how string concatenation and StringBuilder affect the total number of objects created during runtime.
This article explains how Java’s == operator compares object references while the String class’s equals method compares actual character values, covering JVM memory layout, literal pooling, code implementation, and practical examples that clarify common interview questions.
This article explains the JVM's process for creating a Java object, covering class loading checks, memory allocation strategies such as bump-pointer and free list, thread-safe allocation mechanisms, object header composition, instance data layout, padding, and the ways references locate objects via handles or direct pointers.
This article walks through the path from a Java program to the Linux kernel, detailing how the JVM is launched, how libjvm.so is loaded, how pthread_create maps to the clone system call, and what kernel resources are shared by Java threads.
The article shares seven authentic production incident cases—from JVM Full GC spikes and memory leaks to cache avalanches, disk I/O blocks, database deadlocks, DNS hijacking, and bandwidth exhaustion—detailing root causes, step‑by‑step troubleshooting methods, code snippets, and practical mitigation strategies for engineers.
This article examines the Z Garbage Collector (ZGC) introduced in JDK 11, detailing its low‑pause design goals, underlying concurrent marking‑copy algorithm, colored pointer and read‑barrier techniques, practical tuning parameters, real‑world case studies, and the performance impact of upgrading from CMS/G1 to ZGC in high‑throughput, low‑latency services.
This article presents a comprehensive collection of JVM interview questions covering memory areas, garbage collection, class loading, and performance tuning, along with eleven detailed Java mind‑map images that visually summarize core concepts such as the JVM architecture, GC algorithms, and thread management.
This article explores the distinction between OutOfMemory errors and memory leaks in Java, explains how improper use of static fields, unclosed streams, incorrect equals/hashCode implementations, and ThreadLocal can lead to leaks, and provides practical solutions and tools such as JVisualVM to detect and prevent them.
The article details a step‑by‑step forensic analysis of why a Spring Boot application migrated to the MDP framework consumed far more physical memory than its configured 4 GB heap, uncovering off‑heap allocations caused by native code, package‑scanning, and glibc memory‑pool behavior, and explains how limiting scan paths or upgrading Spring Boot resolves the issue.
This article examines why identical-looking string concatenations in Java sometimes use StringBuilder and other times are optimized away, showing bytecode differences, explaining compiler behavior, and summarizing the conditions that affect reference equality.
The article anthropomorphizes several JVM internal threads—FinalizerThread, AppClassLoader, ReferenceHandler, and VMThread—detailing how they handle object finalization, class loading, special reference queues, and VM operations, providing a whimsical yet informative overview of JVM internals.
This article explains the various OutOfMemoryError variants in the Java Virtual Machine, illustrates each with reproducible code examples, analyzes root causes, and provides practical mitigation strategies such as JVM flags, code refactoring, and system‑level adjustments.
After migrating a project to the MDP framework based on Spring Boot, the author observed excessive swap usage and physical memory consumption of 7 GB despite a 4 GB heap limit, and through a series of JVM, system, and native‑code diagnostics identified Spring Boot’s ZipInflaterInputStream native‑memory leak caused by unchecked package scanning.
This article explains the principles behind JVM monitoring tools by introducing JVMTI, the Java Instrumentation API, startup and runtime agents, the Attach mechanism, and demonstrates bytecode manipulation with ASM through detailed code examples and diagrams.
