BestHub
Sign in
Tagged articles
1029 articles
Page 2 of 11
Code Ape Tech Column
Code Ape Tech Column
Jul 3, 2025 · Backend Development

How to Detect and Fix Memory Leaks in Spring Boot Applications

This guide explains the fundamentals of memory leaks in Java, outlines common causes in Spring Boot, and provides step‑by‑step techniques—including GC log analysis, JConsole, VisualVM, MAT, Actuator, custom endpoints, jstack, BTrace, and best‑practice recommendations—to identify, diagnose, and prevent memory leaks for stable long‑running services.

Heap DumpJVMPerformance Monitoring
0 likes · 18 min read
How to Detect and Fix Memory Leaks in Spring Boot Applications
dbaplus Community
dbaplus Community
Jun 30, 2025 · Backend Development

How to Diagnose and Fix JVM GC Pause Issues in High‑Concurrency Microservices

This article walks through a real‑world production case, showing how to systematically detect, analyze, and resolve severe JVM garbage‑collection pauses that caused service timeouts, by examining CPU, memory, GC logs, adjusting collector settings, and aligning JVM threads with Kubernetes resource limits.

JVMKubernetesParallelGCThreads
0 likes · 15 min read
How to Diagnose and Fix JVM GC Pause Issues in High‑Concurrency Microservices
IT Services Circle
IT Services Circle
Jun 30, 2025 · Backend Development

What Makes Java Interviews Tough? A Deep Dive into Concurrency, JVM, MySQL, and More

This article analyzes 58.com’s recent business struggles and layoffs, then presents a comprehensive set of Java interview questions covering synchronized vs. Lock, JVM memory layout, garbage collection, TCP connection teardown, MySQL indexing pitfalls, and common sorting algorithms, providing detailed explanations and code examples.

JVMJavaNetworking
0 likes · 18 min read
What Makes Java Interviews Tough? A Deep Dive into Concurrency, JVM, MySQL, and More
Java Tech Enthusiast
Java Tech Enthusiast
Jun 28, 2025 · Backend Development

Mastering Java Interviews: HashMap, ConcurrentHashMap, JVM GC, and SQL Tricks

This article shares a real HSBC interview experience and provides in‑depth explanations of Java HashMap internals, ConcurrentHashMap locking mechanisms, differences between synchronized and ReentrantLock, JVM garbage‑collection nuances, memory‑overflow causes, and practical SQL queries for extracting top scores.

ConcurrentHashMapHashMapJVM
0 likes · 13 min read
Mastering Java Interviews: HashMap, ConcurrentHashMap, JVM GC, and SQL Tricks
macrozheng
macrozheng
Jun 26, 2025 · Operations

Master JVM Performance: Visual Tools, JConsole, VisualVM & Arthas Guide

This guide introduces JVM performance monitoring by explaining built‑in tools like JConsole and VisualVM, showcasing third‑party solutions such as Arthas, and providing step‑by‑step commands and screenshots to help developers quickly visualize and troubleshoot Java applications.

ArthasJConsoleJVM
0 likes · 12 min read
Master JVM Performance: Visual Tools, JConsole, VisualVM & Arthas Guide
Architect's Must-Have
Architect's Must-Have
Jun 18, 2025 · Backend Development

How to Dynamically Load External JARs into Spring Boot at Runtime

This guide explains step‑by‑step how to load external JAR files into the JVM, configure Spring Boot to recognize them, and choose among four practical solutions—including classpath expansion, Spring Boot loader.path, custom class loaders, and JVM boot classpath tweaks—while highlighting their pros, cons, and required Maven settings.

Custom ClassLoaderJVMJava
0 likes · 10 min read
How to Dynamically Load External JARs into Spring Boot at Runtime
DaTaobao Tech
DaTaobao Tech
Jun 18, 2025 · Backend Development

How to Eliminate GC Pauses in High‑QPS Java Services: A Step‑by‑Step JVM Tuning Guide

This article investigates a high‑concurrency Java service that suffers from long GC pauses during large index swaps, identifies YGC Object Copy as the root cause, and presents a series of JVM tuning techniques—including MaxTenuringThreshold, InitialTenuringThreshold, AlwaysTenure, G1HeapRegionSize, ZGC, and an Eden‑preheat strategy—to achieve near‑zero service disruption and 99.995% success rate.

GC tuningJVMJava
0 likes · 20 min read
How to Eliminate GC Pauses in High‑QPS Java Services: A Step‑by‑Step JVM Tuning Guide
IT Services Circle
IT Services Circle
Jun 15, 2025 · Backend Development

How to Diagnose and Fix JVM GC Pauses in High‑Concurrency Microservices

This article walks through a real‑world production case, detailing how to systematically detect, analyze, and resolve severe JVM garbage‑collection pauses in a high‑concurrency Spring Boot microservice, covering resource analysis, JVM flag tuning, G1GC migration, JMX listeners, and GC‑log investigation.

Garbage CollectionJVMKubernetes
0 likes · 16 min read
How to Diagnose and Fix JVM GC Pauses in High‑Concurrency Microservices
21CTO
21CTO
Jun 10, 2025 · Backend Development

Unlock Java Performance: How JIT and Tiered Compilation Supercharge Your Apps

This article explains how Java's Just‑In‑Time (JIT) compilation and tiered (layered) compilation work together to transform bytecode into native code, improve runtime performance, balance startup speed, and offers practical configuration tips for fine‑tuning JVM behavior.

HotSpotJITJVM
0 likes · 10 min read
Unlock Java Performance: How JIT and Tiered Compilation Supercharge Your Apps
IT Services Circle
IT Services Circle
Jun 10, 2025 · Backend Development

Master TP-Link Backend Interview: JVM, GC, Synchronization, and Redis Cache Strategies

The article shares a personal experience of TP-Link's early campus recruitment and salary expectations, then provides a comprehensive Java backend interview guide covering class‑loader delegation, JVM memory layout, garbage‑collector types, synchronized lock mechanics, and common Redis cache pitfalls with practical solutions.

Garbage CollectionJVMJava
0 likes · 18 min read
Master TP-Link Backend Interview: JVM, GC, Synchronization, and Redis Cache Strategies
Lobster Programming
Lobster Programming
Jun 9, 2025 · Fundamentals

Why JVM Uses Two Survivor Spaces: Boosting GC Efficiency and Memory Utilization

JVM’s generational garbage collection divides the heap into young and old generations, using two Survivor spaces to incrementally age objects, apply a copying algorithm, reduce fragmentation, improve memory utilization, and accelerate short‑lived object reclamation, ultimately enhancing overall GC performance.

Generational GCJVMSurvivor Space
0 likes · 4 min read
Why JVM Uses Two Survivor Spaces: Boosting GC Efficiency and Memory Utilization
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.

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

JVMJavaPerformance Optimization
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
Java Captain
Java Captain
May 21, 2025 · Backend Development

Graceful Shutdown of Spring Boot Applications Using JVM Signals and Actuator

The article explains how to achieve graceful shutdown of Spring Boot services by handling Linux kill signals, registering JVM shutdown hooks, and exposing an Actuator REST endpoint that safely releases resources, stops beans, and terminates the JVM without data loss.

ActuatorGraceful ShutdownJVM
0 likes · 11 min read
Graceful Shutdown of Spring Boot Applications Using JVM Signals and Actuator
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.

JVMJavaSpring Boot
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.

CompilationJVMJava
0 likes · 16 min read
How Does Java Execution Differ from C? A 3‑Minute JVM Deep Dive
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.

JVMJavaResource Management
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
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.

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

Backend DevelopmentJVMPerformance Testing
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.

CustomClassLoaderDebuggingJVM
0 likes · 10 min read
Understanding Java ClassLoader: Common Issues, Root Causes, and Solutions
Cognitive Technology Team
Cognitive Technology Team
Apr 5, 2025 · Fundamentals

Understanding Java ClassLoader.loadClass() API and Its Performance Impact

This article explains how the java.lang.ClassLoader#loadClass() API works, why frequent concurrent calls can cause thread blocking due to internal synchronization, demonstrates the issue with a sample multithreaded program, analyzes thread‑dump data, and provides practical solutions to mitigate the performance problem.

JVMJavaThreadBlocking
0 likes · 12 min read
Understanding Java ClassLoader.loadClass() API and Its Performance Impact
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.

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

Compilation LevelsJITJVM
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.

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

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

Data TypesJVMJava
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.

Data TypesJVMPhone Number
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.

Data TypesJVMPhone Numbers
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.

Backend DevelopmentJVMJava
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.

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

JVMPerformance Testingmemory profiling
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.

Backend DevelopmentCustom 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.

Backend DevelopmentJVMPerformance Testing
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.

Backend DevelopmentJDK LTSJVM
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.

Compiler OptimizationJVMKernel Isolation
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.

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

Backend DevelopmentJVMPerformance Testing
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.

Exception HandlingJVMJava
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.

DockerJVMJava
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
Code Ape Tech Column
Code Ape Tech Column
Dec 10, 2024 · Backend Development

Measuring Per-Request Heap Memory Usage and GC Impact in SpringBoot with JMeter

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.

JMeterJVMMemory Management
0 likes · 9 min read
Measuring Per-Request Heap Memory Usage and GC Impact in SpringBoot with JMeter