Skip to content
Tagged articles

JVM

500 articles · Page 3 of 5
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jun 4, 2025 · Backend Development

Understanding Java Locks, synchronized, ReentrantLock, and Kotlin Coroutine Synchronization

This article explains Java's lock mechanisms—including synchronized, ReentrantLock, and their JVM implementations—covers lock classifications, memory barriers, CAS, and compares them with Kotlin coroutine synchronization tools like Mutex, providing code examples and practical guidance for safe concurrent programming.

ConcurrencyCoroutinesJVM
0 likes · 22 min read
Understanding Java Locks, synchronized, ReentrantLock, and Kotlin Coroutine Synchronization
Raymond Ops
Raymond Ops
Jun 2, 2025 · Operations

Mastering Java JVM Tuning: Essential Commands, GC Strategies, and Reference Types

This guide explains how to launch Java processes from the command line, details key JVM tuning flags such as -X and -XX options, describes garbage collection algorithms, reference strengths, and stop‑the‑world pauses, providing practical examples and diagrams to help developers optimize memory usage and performance.

Garbage CollectionJVMJava
0 likes · 14 min read
Mastering Java JVM Tuning: Essential Commands, GC Strategies, and Reference Types
Su San Talks Tech
Su San Talks Tech
May 24, 2025 · Backend Development

12 Proven SpringBoot Performance Hacks to Boost Your API Speed

Discover twelve practical SpringBoot performance optimization techniques—from connection pool tuning and JVM memory settings to caching, async processing, and full‑stack monitoring—each illustrated with code snippets and actionable guidance to prevent full‑table scans, OOM errors, and latency spikes in high‑traffic applications.

Database IndexingJVMJava
0 likes · 13 min read
12 Proven SpringBoot Performance Hacks to Boost Your API Speed
FunTester
FunTester
May 23, 2025 · Operations

Mastering JVM Thread Dumps: From Diagnosis to Kubernetes Automation

This article explains what JVM thread dumps are, why they are crucial for fault testing, outlines common scenarios such as deadlocks and resource leaks, and provides step‑by‑step methods—including jstack, kill‑3, VisualVM, programmatic APIs, and Fabric8‑driven Kubernetes automation—to capture and analyze them effectively.

DebuggingFabric8JVM
0 likes · 15 min read
Mastering JVM Thread Dumps: From Diagnosis to Kubernetes Automation
Programmer DD
Programmer DD
May 15, 2025 · Backend Development

Boost Spring Boot Performance 3× with JVM Tuning: Practical Parameters

After caching, indexing, and async optimizations still leave a Spring Boot REST API sluggish, this guide shows how fine‑tuning JVM options—such as enabling G1GC, adjusting pause targets, compressing class metadata, shrinking thread stacks, and pre‑touching memory—can triple response speed without changing application code.

G1GCJVMJava
0 likes · 7 min read
Boost Spring Boot Performance 3× with JVM Tuning: Practical Parameters
Cognitive Technology Team
Cognitive Technology Team
May 13, 2025 · Fundamentals

An Introduction to SootUp: Static Analysis of JVM Code

This article introduces the SootUp library, explains how to configure its Maven dependencies, describes the Jimple intermediate representation, and demonstrates how to use SootUp's API to analyze Java source code, bytecode, and method bodies through a series of code examples.

JVMJavaJimple
0 likes · 14 min read
An Introduction to SootUp: Static Analysis of JVM Code
Java One
Java One
May 4, 2025 · Fundamentals

How Does Java Execution Differ from C? A 3‑Minute JVM Deep Dive

This article compares the compilation and runtime processes of C and Java programs, explains Java's class loading, linking, initialization, memory layout, execution engine components, and native interface, and highlights why Java startup is slower than native C execution.

ClassLoaderJVMJava
0 likes · 16 min read
How Does Java Execution Differ from C? A 3‑Minute JVM Deep Dive
Java Captain
Java Captain
May 2, 2025 · Fundamentals

Understanding Java Concurrency: Challenges and Solutions from Hardware to JVM

This article uses real‑world analogies to dissect the three core challenges of Java concurrency—ordering, visibility, and atomicity—and explains how hardware instructions, JVM mechanisms, and Java SDK tools such as locks, CAS, and waiting/notification utilities provide efficient solutions.

CASConcurrencyJVM
0 likes · 14 min read
Understanding Java Concurrency: Challenges and Solutions from Hardware to JVM
IT Services Circle
IT Services Circle
Apr 29, 2025 · Backend Development

Understanding JVM Garbage Collection Mechanisms for Interviews

This article humorously introduces a common interview scenario and then provides a comprehensive overview of JVM garbage collection, covering memory regions, GC roots, collector types like ParNew, G1, CMS, tuning parameters, code examples, and practical tips for diagnosing and optimizing GC behavior.

Garbage CollectionJVMJava
0 likes · 8 min read
Understanding JVM Garbage Collection Mechanisms for Interviews
JD Tech Talk
JD Tech Talk
Apr 29, 2025 · Backend Development

Understanding Java ShutdownHook: Principles, Implementation, and Use Cases

This article explains the concept of Java's Runtime.addShutdownHook, details its underlying implementation in the Runtime and ApplicationShutdownHooks classes, demonstrates usage with code examples, discusses typical application scenarios, potential risks of long‑running hooks, and provides best‑practice recommendations for safe JVM shutdown handling.

JVMJavaShutdownHook
0 likes · 7 min read
Understanding Java ShutdownHook: Principles, Implementation, and Use Cases
JD Cloud Developers
JD Cloud Developers
Apr 29, 2025 · Backend Development

How to Safely Use Java Shutdown Hooks to Clean Up Resources on JVM Exit

This article explains the purpose and inner workings of Java's Runtime.addShutdownHook, walks through the Runtime and ApplicationShutdownHooks source code, demonstrates practical usage with examples, discusses common scenarios, potential risks, and best‑practice solutions for reliable resource cleanup during JVM shutdown.

BackendJVMShutdownHook
0 likes · 9 min read
How to Safely Use Java Shutdown Hooks to Clean Up Resources on JVM Exit
Programmer XiaoFu
Programmer XiaoFu
Apr 22, 2025 · Backend Development

Common Java OOM Types and How to Answer Interview Questions

The article lists the most frequent Java OutOfMemoryError variants, explains their root causes and typical scenarios, provides concrete code examples that trigger each error, and offers practical troubleshooting steps and JVM tuning recommendations for interview preparation.

HeapJVMJava
0 likes · 8 min read
Common Java OOM Types and How to Answer Interview Questions
dbaplus Community
dbaplus Community
Apr 19, 2025 · Fundamentals

Why Thread.sleep(0) Can Influence GC: Uncovering JVM Safepoint Tricks

This article explores the puzzling "prevent gc" comment in RocketMQ source code, explains how Thread.sleep(0) interacts with JVM safepoints, distinguishes counted and uncounted loops, and demonstrates practical experiments that reveal why altering loop variables can change GC behavior.

GCJVMJava
0 likes · 12 min read
Why Thread.sleep(0) Can Influence GC: Uncovering JVM Safepoint Tricks
Top Architect
Top Architect
Apr 10, 2025 · Backend Development

Measuring Heap Memory Consumption of HTTP and RPC Requests in Spring Boot

The article presents a Spring Boot experiment measuring per‑request heap memory usage for HTTP and RPC calls, details the JMeter test setup, analyzes GC logs, reports findings such as ~34KB per HTTP request and 0.5‑1MB per RPC request, offers optimization recommendations, and also includes promotional material for AI‑related products.

JVMSpring Bootbackend development
0 likes · 11 min read
Measuring Heap Memory Consumption of HTTP and RPC Requests in Spring Boot
FunTester
FunTester
Apr 6, 2025 · Backend Development

Understanding Java ClassLoader: Common Issues, Root Causes, and Solutions

This article explains Java's dynamic ClassLoader mechanism, outlines the hierarchy of built‑in loaders, details frequent problems such as ClassNotFoundException, NoClassDefFoundError, ClassCastException and version conflicts, and provides practical troubleshooting steps and best‑practice recommendations for reliable class loading.

ClassLoaderCustomClassLoaderDebugging
0 likes · 10 min read
Understanding Java ClassLoader: Common Issues, Root Causes, and Solutions
Su San Talks Tech
Su San Talks Tech
Mar 28, 2025 · Backend Development

Unlocking Java’s Synchronized: How the JVM Implements Locks

This article explains the low‑level implementation of Java's synchronized keyword, covering monitorenter/monitorexit bytecode, object header structures, Mark Word layouts, and the evolution from heavyweight locks to biased and lightweight locks with lock‑upgrade mechanisms.

ConcurrencyJVMJava
0 likes · 11 min read
Unlocking Java’s Synchronized: How the JVM Implements Locks
Cognitive Technology Team
Cognitive Technology Team
Mar 27, 2025 · Fundamentals

Understanding Tiered Compilation in the JVM

This article explains the JVM's tiered compilation mechanism, detailing the client (C1) and server (C2) JIT compilers, the five compilation levels, code cache organization, relevant JVM flags, and demonstrates method compilation lifecycle through illustrative Java code examples and log analysis.

Code CacheCompilation LevelsJIT
0 likes · 13 min read
Understanding Tiered Compilation in the JVM
Java Tech Enthusiast
Java Tech Enthusiast
Mar 19, 2025 · Backend Development

Java Backend Interview Topics: Thread‑Safe Collections, JVM Memory, Optimistic Lock, Caching, and More

The article reviews key Java backend interview topics—including thread‑safe collections, JVM memory layout and heap tuning, Full GC troubleshooting, Java 8 features, optimistic locking, stock‑over‑sell handling with Redis, MySQL scaling, cache‑consistency patterns, anti‑bot safeguards, and Bloom filters—while noting JD’s recent 30% salary hike for algorithm engineers.

BackendConcurrencyJVM
0 likes · 22 min read
Java Backend Interview Topics: Thread‑Safe Collections, JVM Memory, Optimistic Lock, Caching, and More
Lobster Programming
Lobster Programming
Mar 19, 2025 · Fundamentals

Handle vs Direct Pointer Access in the JVM: Which Is Faster?

An in‑depth look at how the JVM stores object references, comparing handle‑based access with direct pointer access, highlighting their performance trade‑offs, memory overhead, and impact on garbage collection to help developers choose the most suitable approach for their applications.

JVMJavaMemory Management
0 likes · 3 min read
Handle vs Direct Pointer Access in the JVM: Which Is Faster?
Top Architecture Tech Stack
Top Architecture Tech Stack
Mar 17, 2025 · Backend Development

JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Service Node

This article explains how to size and configure JVM options—including heap size, young generation, GC algorithm, thread stack, and metaspace—for a backend service that processes one million login requests per day on an 8 GB machine, providing step‑by‑step calculations, practical examples, and optimization tips.

Garbage CollectionJVMJava
0 likes · 24 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Service Node
Practical DevOps Architecture
Practical DevOps Architecture
Mar 14, 2025 · Backend Development

Comprehensive Java Senior Engineer Curriculum: Architecture Design, System Optimization, and Advanced Topics

This curriculum outlines a 25‑week advanced Java engineering program covering performance optimization, JVM internals, concurrency, distributed storage, MySQL and NoSQL databases, Docker, Kubernetes, microservices, Spring framework deep dives, Nginx, Elasticsearch, Redis, messaging systems, CI/CD tools, and hands‑on project implementation to build high‑performance, scalable backend systems.

JVMJavaKubernetes
0 likes · 3 min read
Comprehensive Java Senior Engineer Curriculum: Architecture Design, System Optimization, and Advanced Topics
Code Ape Tech Column
Code Ape Tech Column
Mar 13, 2025 · Backend Development

Understanding CRaC: Fast JVM Startup with Checkpoint/Restore

This article explains the CRaC (Coordinated Restore at Checkpoint) technology for Java applications, describing its principles, supported environments, practical steps for enabling it with Spring Boot, and use‑case scenarios that dramatically reduce JVM startup time.

CRaCJVMJava
0 likes · 9 min read
Understanding CRaC: Fast JVM Startup with Checkpoint/Restore
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Mar 12, 2025 · Backend Development

What Are GC Roots? Understanding JVM Garbage Collection Basics

The article explains the concept of GC Roots in the JVM, detailing the four main types—stack variables, static fields, constant pool references, and JNI references—along with code examples, and describes how these roots determine object liveness during garbage collection.

GC RootsGarbage CollectionJVM
0 likes · 7 min read
What Are GC Roots? Understanding JVM Garbage Collection Basics
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Mar 11, 2025 · Backend Development

Master Java Garbage Collection: Mark‑Sweep, Copying, Compact & Generational Algorithms

This article explains the main Java garbage collection algorithms—Mark‑Sweep, Mark‑Copying, Mark‑Compact, and Generational Collection—detailing their principles, advantages, and drawbacks, helping developers choose the appropriate strategy for efficient memory management in backend applications.

AlgorithmsGarbage CollectionJVM
0 likes · 5 min read
Master Java Garbage Collection: Mark‑Sweep, Copying, Compact & Generational Algorithms
Java Tech Enthusiast
Java Tech Enthusiast
Mar 3, 2025 · Fundamentals

Choosing Between int and String for Storing Phone Numbers in Java

Because phone numbers are identifiers that can contain symbols and exceed the numeric range of an int, storing them as a String—despite higher memory use—is semantically correct, avoids overflow, preserves formatting, and benefits from JVM string pooling, making String the preferred type in most Java applications.

JVMJavaString
0 likes · 7 min read
Choosing Between int and String for Storing Phone Numbers in Java
Java Backend Technology
Java Backend Technology
Feb 25, 2025 · Fundamentals

Why Storing Phone Numbers as Strings Beats Ints in Java

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.

JVMStringdata types
0 likes · 8 min read
Why Storing Phone Numbers as Strings Beats Ints in Java
macrozheng
macrozheng
Feb 21, 2025 · Fundamentals

Why Storing Phone Numbers as Strings Beats Ints in Java

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.

JVMPhone NumbersString
0 likes · 8 min read
Why Storing Phone Numbers as Strings Beats Ints in Java
Cognitive Technology Team
Cognitive Technology Team
Feb 20, 2025 · Backend Development

Understanding the Java Memory Model and Diagnosing OutOfMemoryError

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.

JVMJavaMemory Management
0 likes · 8 min read
Understanding the Java Memory Model and Diagnosing OutOfMemoryError
Java Tech Enthusiast
Java Tech Enthusiast
Feb 17, 2025 · Fundamentals

Why a Java Volatile Example May Terminate Without Volatile

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.

ConcurrencyHotSpotJVM
0 likes · 11 min read
Why a Java Volatile Example May Terminate Without Volatile
Top Architect
Top Architect
Feb 16, 2025 · Backend Development

Measuring Heap Memory Allocation per HTTP Request in SpringBoot

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.

JVMmemory profilingperformance testing
0 likes · 9 min read
Measuring Heap Memory Allocation per HTTP Request in SpringBoot
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Feb 7, 2025 · Fundamentals

Mastering Java Class Loaders: Break and Follow the Parent Delegation Model

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.

ClassLoaderCustom Class LoaderJVM
0 likes · 11 min read
Mastering Java Class Loaders: Break and Follow the Parent Delegation Model
Architect's Guide
Architect's Guide
Jan 30, 2025 · Backend Development

JVM Parameter Tuning for 1 Million Daily Login Requests on an 8 GB Server

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.

Garbage CollectionJVMJava
0 likes · 24 min read
JVM Parameter Tuning for 1 Million Daily Login Requests on an 8 GB Server
IT Services Circle
IT Services Circle
Jan 29, 2025 · Backend Development

How to Handle Frequent Full GC and High CPU Usage in Java Backend Development

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.

CPU optimizationFull GCJVM
0 likes · 8 min read
How to Handle Frequent Full GC and High CPU Usage in Java Backend Development
Top Architect
Top Architect
Jan 20, 2025 · Backend Development

Diagnosing Excessive Memory Usage in Spring Boot Services: A Real‑World Case Study and Best Practices

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.

BackendDevelopmentJVMJava
0 likes · 9 min read
Diagnosing Excessive Memory Usage in Spring Boot Services: A Real‑World Case Study and Best Practices
IT Services Circle
IT Services Circle
Jan 13, 2025 · Backend Development

Compilation of Common Backend Interview Questions and Answers for Small Companies

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.

BackendGitJVM
0 likes · 6 min read
Compilation of Common Backend Interview Questions and Answers for Small Companies
Top Architect
Top Architect
Jan 10, 2025 · Backend Development

Measuring Heap Memory Allocation per HTTP and RPC Request in SpringBoot

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.

GCJVMSpringBoot
0 likes · 11 min read
Measuring Heap Memory Allocation per HTTP and RPC Request in SpringBoot
DaTaobao Tech
DaTaobao Tech
Jan 6, 2025 · Backend Development

Java 21 LTS Features Overview and Practical Guide

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.

JDK LTSJVMJava 21
0 likes · 16 min read
Java 21 LTS Features Overview and Practical Guide
Lobster Programming
Lobster Programming
Jan 6, 2025 · Fundamentals

How Does the JVM’s Three‑Color Marking Algorithm Optimize Garbage Collection?

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.

CMSG1Garbage Collection
0 likes · 11 min read
How Does the JVM’s Three‑Color Marking Algorithm Optimize Garbage Collection?
Kuaishou Tech
Kuaishou Tech
Dec 30, 2024 · Cloud Native

Kuaishou System Software Team: Architecture, Innovations, and Performance Optimizations

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.

JVMKernel IsolationPerformance Optimization
0 likes · 15 min read
Kuaishou System Software Team: Architecture, Innovations, and Performance Optimizations
Java Tech Enthusiast
Java Tech Enthusiast
Dec 30, 2024 · Backend Development

The Rise of Java: From Toy to Enterprise Powerhouse

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++.

JVMJavaSpring
0 likes · 9 min read
The Rise of Java: From Toy to Enterprise Powerhouse
Raymond Ops
Raymond Ops
Dec 24, 2024 · Operations

How to Diagnose and Fix High CPU and Memory Usage in Java Applications

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.

CPUGCJVM
0 likes · 18 min read
How to Diagnose and Fix High CPU and Memory Usage in Java Applications
Top Architect
Top Architect
Dec 24, 2024 · Backend Development

Measuring Heap Memory Consumption per HTTP Request in SpringBoot Applications

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.

GCJVMSpringBoot
0 likes · 10 min read
Measuring Heap Memory Consumption per HTTP Request in SpringBoot Applications
DeWu Technology
DeWu Technology
Dec 23, 2024 · Fundamentals

Java Null Reference Handling Principles

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.

JVMJavaexception handling
0 likes · 18 min read
Java Null Reference Handling Principles
Top Architecture Tech Stack
Top Architecture Tech Stack
Dec 23, 2024 · Backend Development

JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node

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.

Garbage CollectionJVMJava
0 likes · 25 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node
Lobster Programming
Lobster Programming
Dec 20, 2024 · Fundamentals

Unlocking Java’s Constant Pools: Class, Runtime, and String Explained

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.

Constant PoolJVMJava
0 likes · 3 min read
Unlocking Java’s Constant Pools: Class, Runtime, and String Explained
DevOps Operations Practice
DevOps Operations Practice
Dec 17, 2024 · Backend Development

From CPU Alert to Resolution: A Step‑by‑Step Backend Performance Debugging Guide

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.

JVMJavadatabase
0 likes · 7 min read
From CPU Alert to Resolution: A Step‑by‑Step Backend Performance Debugging Guide
DaTaobao Tech
DaTaobao Tech
Dec 11, 2024 · Backend Development

Resolving Metaspace and Off‑Heap Memory Issues After JDK 11 Upgrade

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.

JDK11JVMMemoryLeak
0 likes · 8 min read
Resolving Metaspace and Off‑Heap Memory Issues After JDK 11 Upgrade
Lobster Programming
Lobster Programming
Dec 5, 2024 · Fundamentals

How Does Java’s JVM Load Classes and Execute Code? A Deep Dive

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.

Class LoadingGarbage CollectionJVM
0 likes · 9 min read
How Does Java’s JVM Load Classes and Execute Code? A Deep Dive
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 3, 2024 · Fundamentals

Unraveling Java’s ClassLoader: From Parent Delegation to Custom Loading

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.

ClassLoaderCustomClassLoaderInstanceKlass
0 likes · 17 min read
Unraveling Java’s ClassLoader: From Parent Delegation to Custom Loading
Top Architect
Top Architect
Nov 29, 2024 · Backend Development

Diagnosing High Memory Usage in Spring Boot Applications and Tuning JVM Parameters

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.

BackendDevelopmentJVMJava
0 likes · 8 min read
Diagnosing High Memory Usage in Spring Boot Applications and Tuning JVM Parameters
Programmer1970
Programmer1970
Nov 25, 2024 · Backend Development

Deep Dive into Elasticsearch Memory Architecture and Optimization

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.

ElasticsearchJVMLucene
0 likes · 8 min read
Deep Dive into Elasticsearch Memory Architecture and Optimization
Top Architect
Top Architect
Nov 22, 2024 · Backend Development

JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node

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.

Garbage CollectionJVMJava
0 likes · 27 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node
Top Architect
Top Architect
Nov 17, 2024 · Backend Development

Diagnosing High Memory Usage in Spring Boot Applications: JVM Parameters and Best Practices

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.

JVMJavaMemoryOptimization
0 likes · 8 min read
Diagnosing High Memory Usage in Spring Boot Applications: JVM Parameters and Best Practices
Selected Java Interview Questions
Selected Java Interview Questions
Nov 17, 2024 · Backend Development

Understanding Java Object Allocation: Stack Allocation, TLAB, and Performance Impact

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.

JVMJavaObject Allocation
0 likes · 6 min read
Understanding Java Object Allocation: Stack Allocation, TLAB, and Performance Impact
Architect
Architect
Nov 14, 2024 · Backend Development

How to Set JVM Parameters for a Platform Handling 1 Million Daily Login Requests on an 8 GB Server

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.

BackendGarbage CollectionJVM
0 likes · 24 min read
How to Set JVM Parameters for a Platform Handling 1 Million Daily Login Requests on an 8 GB Server
Top Architect
Top Architect
Nov 14, 2024 · Backend Development

Measuring Per-Request Heap Memory Usage in SpringBoot Applications

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.

GCJMeterJVM
0 likes · 9 min read
Measuring Per-Request Heap Memory Usage in SpringBoot Applications
Selected Java Interview Questions
Selected Java Interview Questions
Nov 14, 2024 · Backend Development

AviatorScript: High‑Performance JVM‑Based Expression Engine and Scripting Language – Features and Usage Guide

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.

AviatorBackendExpression Engine
0 likes · 8 min read
AviatorScript: High‑Performance JVM‑Based Expression Engine and Scripting Language – Features and Usage Guide
Su San Talks Tech
Su San Talks Tech
Nov 7, 2024 · Backend Development

Optimizing JVM GC for High‑Throughput E‑Commerce Order Systems

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.

Garbage CollectionJVMJava
0 likes · 6 min read
Optimizing JVM GC for High‑Throughput E‑Commerce Order Systems