This article analyzes the trade‑offs between using int and String to store phone numbers in Java, covering type characteristics, the semantic nature of phone numbers, JVM bytecode implications, performance considerations, and practical case studies to guide developers toward the optimal choice.
The article examines the trade‑offs of using Java's primitive int versus the String class to store phone numbers, covering memory usage, JVM bytecode behavior, data semantics, and practical performance implications for large‑scale systems.
This article explains why using Java's String type for phone numbers is more memory‑efficient, semantically correct, and performant than using primitive int, covering JVM bytecode, memory layout, string pool optimization, and real‑world case studies.
This article explains the Java memory model, outlines common OutOfMemoryError types, and provides a step‑by‑step guide for diagnosing, fixing, and preventing memory‑related issues in large‑scale Java applications, including heap, metaspace, and stack analysis, JVM flag tuning, and best‑practice recommendations for resource handling and monitoring.
This article investigates whether the JVM terminates when a thread encounters an OutOfMemoryError, demonstrating through Spring Boot controllers and multithreaded examples how main and child threads, daemon settings, and explicit OOM handling affect JVM shutdown behavior.
This article explains Java's ClassLoader mechanism, its loading, linking, and initialization phases, the parent‑delegation hierarchy, common problems such as ClassNotFoundException and OOM, and provides practical troubleshooting steps and best practices for managing dynamic class loading.
The program that loops on a non‑volatile boolean flag sometimes terminates because changing the counter to a volatile int or to an Integer causes the JVM to emit hidden memory barriers on reference writes, making the flag visible, but this behavior is JVM‑specific and not a reliable substitute for declaring the flag volatile.
This article details a SpringBoot experiment using JMeter to measure the heap memory allocated per HTTP request, analyzes GC logs, and discusses how request size and logging affect memory consumption, providing practical JVM tuning insights for backend developers.
This article explains the Concurrent Mark Sweep (CMS) garbage collector, detailing its five phases—Initial Mark, Concurrent Mark, Remark, Concurrent Sweep, and Concurrent Reset—while highlighting how each step works to minimize pause times during old‑generation memory reclamation in Java.
This article examines the drawbacks of using Java's primitive int type to store phone numbers, explains how primitive and reference types differ in memory and performance, and demonstrates why the String type, with JVM optimizations like the string pool, provides a safer, more flexible solution for global telephone data.
This article explains how to create custom Java class loaders by extending java.lang.ClassLoader, when to override findClass versus loadClass, demonstrates both adhering to and breaking the parent delegation model with complete code examples, and discusses common scenarios such as web servers, SPI, and hot deployment where the delegation mechanism is intentionally altered.
This article explains Java's class loading mechanism, the three built‑in class loaders, the parent‑delegation model, reasons for using it, how to create custom loaders, and the detailed phases of loading, linking, initialization, usage, and unloading.
This article explains the Java Virtual Machine's two subsystems—Class Loader and Execution Engine—and its two main components—Runtime Data Area and Native Interface—detailing their functions, internal structures, and the overall execution workflow of Java programs.
This article walks through a systematic, eight‑step approach to sizing and configuring JVM memory parameters—including heap, young generation, stack, object age thresholds, and garbage‑collector selection—so that a service handling one million daily logins on an 8 GB machine can achieve stable performance and predictable GC behavior.
This article explains common interview questions on frequent Full GC and high CPU usage in Java backend development, detailing root causes, JVM parameter adjustments, memory leak prevention, and code optimization techniques, along with practical code examples and tool recommendations for effective performance tuning.
This article documents a step‑by‑step investigation of a Java 11 application that suffered OS‑level OOM despite a 4 GB heap, revealing that multiple Netty PooledByteBufAllocator instances loaded by different class loaders consumed far more native memory than expected.
This article recounts a production incident where Spring Boot services consumed excessive memory, explains how to diagnose the issue using jps and jmap, discusses default JVM heap settings, offers practical remediation steps, and also contains promotional material for AI community services and related offers.
This article presents a comprehensive collection of written‑test and interview questions covering Java basics, Spring MVC annotations, JVM memory, garbage collection, database design, transaction management, distributed systems, version control, and development workflow, aimed at helping candidates prepare for small‑company technical interviews.
This article details a practical experiment using SpringBoot 2.5.4 and JMeter to measure the heap memory allocated by individual HTTP and RPC requests, analyzes GC logs, and demonstrates how request size and logging affect memory consumption, providing insights for backend performance optimization.
This guide explains why Tomcat's default development settings need tuning for production, covering JVM memory model basics, configuration file edits, thread pool and connector adjustments, as well as security hardening steps to improve performance and stability.
This article walks readers through upgrading from Java 11 to the Java 21 LTS by explaining the six‑month release cadence, JEP process, and SDKman setup, then demonstrates practical code examples for twelve new features—including preview Unnamed Classes, String Templates, Scoped Values, Structured Concurrency, Vector API, Virtual Threads, and Generational ZGC—highlighting their motivations, benefits, and production considerations.
This article breaks down Java's three memory regions—Heap, Off‑Heap, and No‑Heap—detailing their definitions, management mechanisms, performance impacts, typical use cases, and provides concrete code samples for allocating each type of memory.
The article explains JVM garbage‑collection techniques, comparing simple reference‑counting and reachability analysis, then details the three‑color marking algorithm—including its phases, color semantics, step‑by‑step process, and common issues like over‑marking and under‑marking—followed by solutions used in CMS and G1 collectors.
This guide explains how to optimize Tomcat by adjusting maxThreads, acceptCount, maxConnections, and connectionTimeout, while also tuning Linux kernel parameters, TCP settings, and JVM options to achieve balanced CPU and I/O performance for high‑concurrency web services.
This article presents an overview of Kuaishou's system software team, detailing its core value, challenges, the "Four Horizontal Four Vertical" architecture, JVM innovations such as transparent coroutines and checkpointing, advanced compilation techniques, kernel isolation for cloud‑native workloads, and extensive performance‑boosting strategies that have dramatically improved resource utilization and stability.
The article investigates a mysterious "prevent gc" comment in RocketMQ's source, explains how Thread.sleep(0) forces a JVM safepoint to mitigate long GC pauses, and demonstrates that changing loop counters from int to long eliminates the need for the hack.
A senior developer recounts switching from C# and Python to Java for web projects and higher pay, illustrating Java’s evolution from a “toy” language with early JVM limits to an enterprise powerhouse driven by JIT, Spring Boot, and robust performance that now rivals C++.
This article explains how the i++ and ++i operators are implemented at the JVM bytecode level, using concrete code examples and step‑by‑step analysis of each instruction to show why i++ can output 8 while ++i yields 9.
This article explains how Java's garbage collectors work, covering generational memory spaces, major algorithms such as mark‑sweep, mark‑compact, and copy, the most common collectors for young and old generations, safe points, throughput calculations, and tuning parameters.
This guide walks through identifying Java processes that cause high CPU load, extracting the hottest threads with top and jstack, analyzing JVM memory regions, interpreting GC logs, and applying practical JVM tuning parameters and tools such as jmap, jstat, and MAT to resolve performance bottlenecks.
This article presents a systematic experiment that uses JMeter to generate HTTP requests against a SpringBoot 2.5.4 service, records detailed GC logs, and calculates that each HTTP call consumes roughly 34 KB of heap memory, while logging and payload size can significantly increase the allocation.
Java’s ubiquitous NullPointerException stems from Tony Hoare’s 1965 introduction of the null reference—a design he later called his ‘billion-dollar mistake’—and the JVM mitigates its cost by forgoing proactive checks, instead relying on OS signals like SIGSEGV to detect nulls and throw the exception only when they actually occur.
This article explains how to plan capacity, choose the appropriate garbage collector, allocate heap and non‑heap memory, and configure JVM flags—including Xms, Xmx, Xmn, Xss, and GC‑specific options—to reliably support a service node with 8 GB RAM handling one million login requests per day.
This article explains Java’s constant pools, detailing the class constant pool stored in .class files, its transformation into the runtime constant pool during JVM loading, and the specialized string constant pool that optimizes memory usage, including recent changes moving it to heap memory.
This article recounts a production incident where Spring Boot services consumed excessive memory, details step‑by‑step diagnostics using jps and jmap, explains default JVM heap settings, offers remediation recommendations, and also includes promotional material for AI services.
This article recounts a midnight CPU alert incident and walks through systematic backend troubleshooting—from initial system checks and JVM profiling to algorithm refactoring, database indexing, Docker‑based isolation, and proactive monitoring—demonstrating how to restore service performance and prevent future outages.
This article investigates the common belief that Java try‑catch blocks severely degrade performance by examining JVM exception handling mechanisms, bytecode generation, JIT and AOT compilation effects, and presenting detailed benchmark tests under various JVM modes.
After upgrading core services to JDK 11, the team encountered a Metaspace rise and off‑heap memory growth caused by class‑loading changes and Netty’s disabled native buffers, which were resolved by expanding Metaspace to 768 MB and adding JVM options to enable Netty reflection and open required modules, restoring normal memory usage.
Java 21's virtual threads provide lightweight, high‑concurrency execution managed by the JVM, and this article explains their fundamentals, demonstrates basic creation, shows how to enable them in Spring Boot, and presents performance benchmarks comparing virtual threads to traditional threads.
This article demonstrates how to experimentally determine the heap memory allocated by individual HTTP and RPC requests in a SpringBoot application using JMeter load testing, GC logging, and code analysis, providing insights into memory consumption, GC frequency, and optimization strategies for backend performance.
This article explains how Java classes are loaded into the JVM, details the class loader’s parent‑delegation mechanism, and walks through the execution flow of a sample program, covering stack frames, heap allocation, dynamic linking, method area, program counter, native method stack, and garbage collection.
This article explores Java's class loading mechanism in depth, covering when and how classes are loaded, the parent‑delegation model, the internal role of ClassFileParser and InstanceKlass, parallel loading nuances, and practical ways to break or extend the delegation chain with custom class loaders.
This article details a real‑world case where Spring Boot microservices on a 64 GB server consumed excessive memory, explains how to diagnose the issue using jps and jmap, discusses default JVM heap settings, and provides practical recommendations for tuning JVM parameters to prevent similar problems.
The article explains Elasticsearch's on‑heap and off‑heap memory design, details each memory pool and its management via LRU, describes Lucene's role in off‑heap storage, and provides practical tips for configuring JVM heap size, cache strategies, and monitoring to achieve stable, high‑performance search.
Chief designer Michail Zarečenskij explains Kotlin’s evolution from a Java alternative to a multiplatform language, its ongoing reliance on JVM interoperability, hopes for Project Valhalla, the impact of Project Loom on coroutines, and upcoming features slated for the next Kotlin release.
This article walks through a systematic approach to sizing and configuring JVM parameters—including heap size, young generation, GC algorithm selection, and advanced options—for a high‑traffic login service that processes one million requests per day on a server with 8 GB of memory, while explaining the underlying performance‑analysis methodology.
This article compares coroutines and threads for high‑concurrency and I/O‑intensive workloads, summarizes multithreading fundamentals, presents performance‑critical code examples, and discusses JVM memory, locking, middleware, and various optimization techniques for backend systems.
This article records and reviews a production incident where multiple Spring Boot services consumed excessive memory, explains how default JVM settings caused each instance to allocate up to 12 GB of heap, and provides step‑by‑step diagnostics, configuration guidelines, and optimization recommendations for backend developers.
This article examines a Java micro‑benchmark that measures object creation time, explains why printing objects dramatically slows execution, and details JVM allocation strategies such as stack allocation, escape analysis, scalar replacement, and Thread‑Local Allocation Buffers (TLAB) with relevant parameters.
This article explains, step by step, how to estimate capacity, choose the appropriate garbage collector, size the young and old generations, configure stack memory, adjust object aging thresholds, and fine‑tune CMS or G1 settings so that a Java service handling one million daily logins can run reliably on an 8 GB node.
The article details a SpringBoot experiment that uses JMeter to send 20,000 HTTP requests, captures detailed GC logs, and demonstrates that each request consumes roughly 34 KB of heap memory, with larger payloads and logging increasing the usage, highlighting the importance of memory‑aware coding and log management.
This article introduces AviatorScript, a lightweight high‑performance expression engine and scripting language for the JVM (including Android), outlines its core features, demonstrates basic expression evaluation, variable handling, built‑in and custom functions, and shows how to run full scripts with code examples.
This article explains how to analyze per‑second object memory usage in a 100k TPS e‑commerce order flow, choose an appropriate garbage collector, set heap and young‑generation sizes, and apply common JVM tuning parameters to reduce Full GC pauses and improve latency and throughput.
This article debunks the myth that Java try‑catch blocks severely degrade performance by explaining JVM exception handling, showing bytecode differences, presenting benchmark code, and reporting test results under interpreter and JIT modes, concluding that the impact is negligible when no exception occurs.
This article explains the three-part structure of a Java object in the HotSpot JVM—object header, instance data, and alignment padding—detailing the Mark Word and Klass Pointer fields, their bit‑level layout, and how they affect memory size, GC age, and locking behavior.
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 the theoretical and practical limits of Java String length, covering compile‑time restrictions, UTF‑8 encoding effects, constant‑pool constraints, runtime constructor limits, memory consumption, and JDK 9 optimizations, with illustrative code examples.
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.
