BestHub
Sign in
Tagged articles
1031 articles
Page 3 of 11
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
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.

Garbage CollectionJVMJava
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.

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

Garbage CollectionJVMJava
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.

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

AviatorExpression EngineJVM
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
FunTester
FunTester
Nov 4, 2024 · Backend Development

Mastering Java Fault Injection with Byteman: A Hands‑On Guide

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.

BytemanFault InjectionJVM
0 likes · 12 min read
Mastering Java Fault Injection with Byteman: A Hands‑On Guide
Sanyou's Java Diary
Sanyou's Java Diary
Oct 28, 2024 · Fundamentals

Master JVM Memory Troubleshooting: A Step‑by‑Step Guide

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.

DirectMemoryHeapJVM
0 likes · 56 min read
Master JVM Memory Troubleshooting: A Step‑by‑Step Guide
Cognitive Technology Team
Cognitive Technology Team
Oct 23, 2024 · Fundamentals

Overview of Garbage Collection Algorithms and JVM Garbage Collectors

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.

Copy AlgorithmG1Garbage Collection
0 likes · 9 min read
Overview of Garbage Collection Algorithms and JVM Garbage Collectors
Architect
Architect
Oct 19, 2024 · Operations

Why Does Your Java Application Crash? Decoding JVM Crash Logs and Core Dumps

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.

DebuggingJVMJava
0 likes · 37 min read
Why Does Your Java Application Crash? Decoding JVM Crash Logs and Core Dumps
Top Architect
Top Architect
Oct 15, 2024 · Backend Development

Measuring Heap Memory Allocation per HTTP Request in SpringBoot Applications

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.

JVMMemoryOptimizationPerformanceTesting
0 likes · 11 min read
Measuring Heap Memory Allocation per HTTP Request in SpringBoot Applications
Java Backend Technology
Java Backend Technology
Oct 14, 2024 · Cloud Native

Why ExitOnOutOfMemoryError Beats HeapDumpOnOutOfMemoryError in Containerized Java Apps

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.

ContainerJVMJava
0 likes · 11 min read
Why ExitOnOutOfMemoryError Beats HeapDumpOnOutOfMemoryError in Containerized Java Apps
MaGe Linux Operations
MaGe Linux Operations
Oct 8, 2024 · Backend Development

Master Java JVM Tuning: Key Commands, GC Options & Reference Types

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.

Garbage CollectionJVMJava
0 likes · 13 min read
Master Java JVM Tuning: Key Commands, GC Options & Reference Types
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 27, 2024 · Backend Development

Master JVM Tuning: Practical Steps, Tools, and Real-World Code Example

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.

Backend DevelopmentGarbage CollectionJVM
0 likes · 7 min read
Master JVM Tuning: Practical Steps, Tools, and Real-World Code Example
IT Services Circle
IT Services Circle
Sep 13, 2024 · Backend Development

Comprehensive Java Backend Interview Guide: Collections, JVM, OS, Networking, MySQL, Redis, and Algorithms

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.

JVMJavabackend interview
0 likes · 18 min read
Comprehensive Java Backend Interview Guide: Collections, JVM, OS, Networking, MySQL, Redis, and Algorithms
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Sep 6, 2024 · Fundamentals

Understanding Java Garbage Collection Algorithms and Their Use Cases

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.

GC AlgorithmsGarbage CollectionJVM
0 likes · 19 min read
Understanding Java Garbage Collection Algorithms and Their Use Cases
Selected Java Interview Questions
Selected Java Interview Questions
Aug 31, 2024 · Backend Development

Root Cause Analysis of Excessive Swap Usage in a Spring Boot Project: Native Memory Leak Triggered by MCC Package Scanning

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.

JVMJavaMCC
0 likes · 13 min read
Root Cause Analysis of Excessive Swap Usage in a Spring Boot Project: Native Memory Leak Triggered by MCC Package Scanning
Top Architect
Top Architect
Aug 30, 2024 · Backend Development

Diagnosing High Memory Usage in Spring Boot Applications: JVM Parameters and Troubleshooting Steps

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.

Backend DevelopmentJVMJava
0 likes · 8 min read
Diagnosing High Memory Usage in Spring Boot Applications: JVM Parameters and Troubleshooting Steps
Java Tech Enthusiast
Java Tech Enthusiast
Aug 29, 2024 · Backend Development

Comprehensive Backend Interview Guide: Network, Security, JVM, Spring, Redis, MySQL and More

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.

InterviewJVMRedis
0 likes · 44 min read
Comprehensive Backend Interview Guide: Network, Security, JVM, Spring, Redis, MySQL and More
Top Architecture Tech Stack
Top Architecture Tech Stack
Aug 27, 2024 · Backend Development

Understanding Java's Parent Delegation Model for Class Loaders

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.

JVMJavaParent Delegation
0 likes · 10 min read
Understanding Java's Parent Delegation Model for Class Loaders
DeWu Technology
DeWu Technology
Aug 26, 2024 · Fundamentals

Understanding Java's invokedynamic and Lambda Implementation

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.

JVMJavaLambda
0 likes · 16 min read
Understanding Java's invokedynamic and Lambda Implementation
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 23, 2024 · Fundamentals

Understanding JVM Memory Structure and Object Lifecycle

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.

Garbage CollectionJVMMetaspace
0 likes · 11 min read
Understanding JVM Memory Structure and Object Lifecycle
Su San Talks Tech
Su San Talks Tech
Aug 22, 2024 · Backend Development

Why AviatorScript Is the Lightweight JVM Rule Engine You Need

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.

AviatorScriptBackend DevelopmentJVM
0 likes · 19 min read
Why AviatorScript Is the Lightweight JVM Rule Engine You Need
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Aug 4, 2024 · Backend Development

Understanding Java Memory Leaks and How to Prevent Them

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.

Best PracticesJVMJava
0 likes · 9 min read
Understanding Java Memory Leaks and How to Prevent Them
JD Retail Technology
JD Retail Technology
Aug 2, 2024 · Operations

JVM Memory Model, Garbage Collection, and Optimization Guide

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.

Garbage CollectionJVMJava
0 likes · 17 min read
JVM Memory Model, Garbage Collection, and Optimization Guide
JavaEdge
JavaEdge
Jul 31, 2024 · Backend Development

How a Five‑Tier Cache Boosts E‑Commerce Product Retrieval Speed

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.

CachingJVMe-commerce
0 likes · 7 min read
How a Five‑Tier Cache Boosts E‑Commerce Product Retrieval Speed
IT Services Circle
IT Services Circle
Jul 19, 2024 · Backend Development

Comprehensive Backend Interview Guide: MySQL Indexes, Redis Architecture, Java SpringBoot Auto‑Configuration, and JVM Memory Management

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.

JVMJavaSpringBoot
0 likes · 40 min read
Comprehensive Backend Interview Guide: MySQL Indexes, Redis Architecture, Java SpringBoot Auto‑Configuration, and JVM Memory Management
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 18, 2024 · Fundamentals

Unlock JVM Performance: How Tiered Compilation and JIT Optimizations Work

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.

Escape AnalysisJIT OptimizationJVM
0 likes · 29 min read
Unlock JVM Performance: How Tiered Compilation and JIT Optimizations Work
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 26, 2024 · Backend Development

JVM Class Loading Explained: From Loading to Initialization

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.

Backend DevelopmentJVMJava
0 likes · 7 min read
JVM Class Loading Explained: From Loading to Initialization
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 26, 2024 · Fundamentals

Mastering Java G1 and ZGC: Deep Dive into Modern Garbage Collectors

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.

G1Garbage CollectionJVM
0 likes · 30 min read
Mastering Java G1 and ZGC: Deep Dive into Modern Garbage Collectors
Bin's Tech Cabin
Bin's Tech Cabin
Jun 19, 2024 · Fundamentals

Why PhantomReference Can Track GC While WeakReference Can’t in ZGC

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.

Garbage CollectionJVMJava
0 likes · 11 min read
Why PhantomReference Can Track GC While WeakReference Can’t in ZGC
Bin's Tech Cabin
Bin's Tech Cabin
Jun 17, 2024 · Fundamentals

How Does Java’s FinalReference Keep Objects Alive During GC?

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.

FinalReferenceFinalizerThreadGarbage Collection
0 likes · 20 min read
How Does Java’s FinalReference Keep Objects Alive During GC?
Bin's Tech Cabin
Bin's Tech Cabin
Jun 15, 2024 · Fundamentals

When Does ZGC Actually Clear SoftReferences? Inside the JVM Reference Policy

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.

Garbage CollectionJVMReference Policy
0 likes · 15 min read
When Does ZGC Actually Clear SoftReferences? Inside the JVM Reference Policy
JD Tech
JD Tech
Jun 13, 2024 · Backend Development

Investigation of Log4j2 Asynchronous Logging Memory Growth and Mitigation Strategies

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.

JVMJavaasynchronous logging
0 likes · 18 min read
Investigation of Log4j2 Asynchronous Logging Memory Growth and Mitigation Strategies
macrozheng
macrozheng
Jun 7, 2024 · Backend Development

Boost Java Startup Speed with Class Data Sharing (CDS): A Step‑by‑Step Guide

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.

Backend DevelopmentClass Data SharingJVM
0 likes · 9 min read
Boost Java Startup Speed with Class Data Sharing (CDS): A Step‑by‑Step Guide
21CTO
21CTO
Jun 4, 2024 · Backend Development

Why BoxLang Could Redefine JVM Development: Insights from Its CEO

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.

BoxLangDynamic LanguageInterview
0 likes · 11 min read
Why BoxLang Could Redefine JVM Development: Insights from Its CEO
Java Tech Enthusiast
Java Tech Enthusiast
May 27, 2024 · Backend Development

Understanding Garbage Collection in the JVM

The author celebrates landing a new job while emphasizing that mastering Java's garbage collection—identifying and reclaiming memory from unreachable objects via algorithms like reference counting or reachability analysis—is essential for robust backend development and preventing memory overflow.

Garbage CollectionJVMJava
0 likes · 4 min read
Understanding Garbage Collection in the JVM
Architecture Digest
Architecture Digest
May 27, 2024 · Backend Development

Upgrading to JDK 17 with ZGC: Performance Comparison and Migration Guide

This article explains why upgrading to JDK 17 and switching to the low‑latency ZGC garbage collector can dramatically reduce pause times and improve throughput, compares GC and CPU metrics against G1, and provides step‑by‑step installation and JVM tuning instructions with code examples.

Garbage CollectionJVMJava
0 likes · 6 min read
Upgrading to JDK 17 with ZGC: Performance Comparison and Migration Guide
IT Services Circle
IT Services Circle
Apr 13, 2024 · Fundamentals

Java Interview Questions: Collections, HashMap, Concurrency, JVM Memory, GC, References, and Redis

This article compiles a set of Java interview questions covering the differences between ArrayList and LinkedList, the internal workings and resizing of HashMap, concurrency primitives like synchronized and ReentrantLock, JVM memory layout, garbage‑collection algorithms, reference types, and Redis persistence and distributed‑lock mechanisms.

HashMapInterviewJVM
0 likes · 21 min read
Java Interview Questions: Collections, HashMap, Concurrency, JVM Memory, GC, References, and Redis
Bin's Tech Cabin
Bin's Tech Cabin
Apr 1, 2024 · Fundamentals

Why System.gc Matters for Java NIO Memory Management

This article explains how Java's System.gc triggers full or concurrent garbage collection in NIO scenarios, detailing the JVM's handling of out‑of‑memory errors during memory‑mapped file operations and direct buffer allocations, and examines the behavior across various garbage collectors such as Serial, Parallel, G1, ZGC, and Shenandoah.

DirectByteBufferGarbage CollectionJVM
0 likes · 20 min read
Why System.gc Matters for Java NIO Memory Management
MaGe Linux Operations
MaGe Linux Operations
Mar 31, 2024 · Backend Development

Mastering Tomcat Performance: Key Tuning Parameters and Best Practices

This article explains how to optimize Tomcat 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 balanced performance for both CPU‑bound and I/O‑bound workloads.

JVMLinux kernelPerformance tuning
0 likes · 14 min read
Mastering Tomcat Performance: Key Tuning Parameters and Best Practices
DaTaobao Tech
DaTaobao Tech
Mar 22, 2024 · Backend Development

Understanding JVM Memory, GC, and Performance Tuning

The article explains JVM runtime memory regions, heap allocation and generational layout, object reference types, major garbage‑collection algorithms and collectors, class‑loading phases, and provides practical tuning commands and case studies for optimizing GC pauses, preventing memory leaks, and diagnosing performance bottlenecks.

GarbageCollectionJVMJava
0 likes · 33 min read
Understanding JVM Memory, GC, and Performance Tuning
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 21, 2024 · Fundamentals

Mastering JVM Memory: From Heap Layout to Garbage Collection Tuning

This article provides a comprehensive guide to JVM internals, covering runtime data areas, heap segmentation, object allocation, reference types, class loading phases, garbage collection algorithms, collector choices across JDK versions, performance tuning commands, and practical troubleshooting techniques for production Java applications.

Garbage CollectionJVMMemory Management
0 likes · 38 min read
Mastering JVM Memory: From Heap Layout to Garbage Collection Tuning
vivo Internet Technology
vivo Internet Technology
Mar 19, 2024 · Backend Development

Java 8 Memory Management and Garbage Collection Analysis

The article offers a thorough overview of Java 8 memory management, detailing JVM memory regions, object eligibility, major garbage‑collection algorithms and generational models, comparing Serial, Parallel, CMS and G1 collectors, and presenting practical heap‑dump analysis techniques for diagnosing leaks and performance issues.

GC AlgorithmsHeap AnalysisJVM
0 likes · 29 min read
Java 8 Memory Management and Garbage Collection Analysis
Java Backend Technology
Java Backend Technology
Mar 19, 2024 · Backend Development

6 Common Java OOM Scenarios and How to Prevent Them

This article explains six typical OutOfMemoryError situations in Java—heap, native thread, stack overflow, direct buffer, GC overhead, and Metaspace—provides code examples that trigger each issue, shows the resulting exception messages, and offers practical tips such as using thread pools, limiting recursion depth, adjusting GC settings, and configuring Metaspace to avoid these memory problems.

HeapJVMJava
0 likes · 9 min read
6 Common Java OOM Scenarios and How to Prevent Them
Su San Talks Tech
Su San Talks Tech
Mar 18, 2024 · Backend Development

6 Common Java OOM Scenarios and How to Prevent Them

This article explores six typical OutOfMemoryError situations in Java—including heap, stack, direct memory, GC overhead, and metaspace issues—explains their root causes, provides reproducible code examples, and offers practical tips to avoid or mitigate each problem.

JVMJavaMemory Management
0 likes · 8 min read
6 Common Java OOM Scenarios and How to Prevent Them
Sanyou's Java Diary
Sanyou's Java Diary
Mar 4, 2024 · Fundamentals

Master JVM Memory Troubleshooting: A Complete Step‑by‑Step Guide

This comprehensive guide presents a systematic, step‑by‑step process for diagnosing JVM memory problems—including heap, Metaspace, DirectMemory, JNI memory, and stack issues—using Alibaba Cloud ARMS, ATP, standard JDK tools, and best‑practice commands to quickly locate root causes and apply effective solutions.

HeapJVMMemory
0 likes · 56 min read
Master JVM Memory Troubleshooting: A Complete Step‑by‑Step Guide
Su San Talks Tech
Su San Talks Tech
Mar 1, 2024 · Backend Development

Master JVM Tuning: When, How, and Which Tools to Optimize Java Performance

This article explains why JVM tuning matters, identifies scenarios that require tuning such as performance bottlenecks, memory overflows, and concurrency issues, and then details monitoring and diagnostic tools—including JDK command‑line utilities and third‑party solutions—followed by a comprehensive guide to JVM parameters, garbage‑collector selection, and practical ways to apply these settings in production environments.

JVMJavaPerformance tuning
0 likes · 18 min read
Master JVM Tuning: When, How, and Which Tools to Optimize Java Performance
MaGe Linux Operations
MaGe Linux Operations
Feb 29, 2024 · Backend Development

Mastering JVM Heap Settings in Docker: Best Parameters Across JDK Versions

This guide explains how JVM determines heap size on physical machines versus containers, compares behavior of different JDK releases, and provides concrete Docker commands and JVM flags—such as -Xms/-Xmx, -XX:+UseCGroupMemoryLimitForHeap, and MaxRAMPercentage—to reliably control memory usage in containerized Java applications.

ContainerizationDockerJVM
0 likes · 11 min read
Mastering JVM Heap Settings in Docker: Best Parameters Across JDK Versions
DeWu Technology
DeWu Technology
Feb 28, 2024 · Cloud Native

Technical Overview of ZingJDK: ReadyNow, Falcon JIT, and C4 GC

ZingJDK, Azul’s high‑performance commercial JDK built on OpenJDK, combines ReadyNow® pre‑warming, the LLVM‑based Falcon JIT compiler, the pause‑free C4 concurrent compacting garbage collector, and a cloud‑native off‑load compiler to deliver dramatically faster startup and execution across JDK 7‑21, though it lacks dynamic Attach support and requires a commercial license.

Cloud NativeGarbage CollectionJIT
0 likes · 17 min read
Technical Overview of ZingJDK: ReadyNow, Falcon JIT, and C4 GC
DeWu Technology
DeWu Technology
Feb 23, 2024 · Backend Development

Understanding Thread Pool Exhaustion in Dubbo: Causes and Diagnosis

The article explains that Dubbo’s zero‑capacity SynchronousQueue causes a thread‑pool “EXHAUSTED” error when incoming requests outpace consumption, often triggered by slow DB queries, lock contention, or network jitter, and that JVM stop‑the‑world pauses fill the OS TCP receive buffer, creating a post‑pause traffic burst that overwhelms the pool, with diagnostics using safepoint statistics.

DubboJVMPerformance
0 likes · 9 min read
Understanding Thread Pool Exhaustion in Dubbo: Causes and Diagnosis
Top Architect
Top Architect
Feb 20, 2024 · Backend Development

JVM Garbage Collection Tuning Experience: Reducing FullGC Frequency and Solving Memory Leaks

Over a month of systematic JVM tuning, the author reduced FullGC frequency from 40 times per day to once every ten days, halved YoungGC time, identified and fixed a memory leak caused by anonymous inner‑class listeners, and documented the step‑by‑step optimization process with configuration changes and performance results.

Garbage CollectionJVMJava
0 likes · 12 min read
JVM Garbage Collection Tuning Experience: Reducing FullGC Frequency and Solving Memory Leaks
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 31, 2024 · Backend Development

Understanding Java JVM Garbage Collectors: From Serial to Shenandoah

This article explains the main Java JVM garbage collectors—including Serial, Parallel, CMS, G1, ZGC, Epsilon, and Shenandoah—detailing their architectures, pause characteristics, suitable workloads, and key advantages, helping developers choose the right collector for different application sizes and latency requirements.

Garbage CollectionJVMJava
0 likes · 7 min read
Understanding Java JVM Garbage Collectors: From Serial to Shenandoah
macrozheng
macrozheng
Jan 25, 2024 · Backend Development

How to Slash Spring Boot Memory Usage by Over 40% for Local Development

This guide explains why Spring Boot applications consume memory, shows how to configure the JVM and Tomcat settings, and demonstrates using Docker‑compose to apply these tweaks, enabling developers to reduce local memory usage by more than 40% and speed up development cycles.

DockerJVMMemory Optimization
0 likes · 7 min read
How to Slash Spring Boot Memory Usage by Over 40% for Local Development
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 22, 2024 · Fundamentals

Understanding JVM Architecture and Core Mechanisms

This article provides a comprehensive overview of the Java Virtual Machine, detailing its architecture, class loading process, runtime data areas, and execution engine, including interpreter and JIT compilation, to help readers grasp JVM fundamentals for Java development and interview preparation.

JITJVMJava
0 likes · 8 min read
Understanding JVM Architecture and Core Mechanisms
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 20, 2024 · Backend Development

Master Java’s Parent Delegation Model: How Class Loaders Work and Why It Matters

This article provides a detailed explanation of Java’s parent delegation model, covering its definition, visual diagrams, advantages and disadvantages, and a six-step loading process, helping readers understand how class loaders prioritize parent loaders to ensure security and avoid duplicate class loading.

JVMJavaParent Delegation
0 likes · 5 min read
Master Java’s Parent Delegation Model: How Class Loaders Work and Why It Matters
Huolala Tech
Huolala Tech
Jan 18, 2024 · Fundamentals

Why G1’s Humongous Objects Trigger Midnight Old‑Gen Spikes and How to Diagnose Them

This article walks through a real‑world G1 GC incident where massive humongous object allocations caused old‑generation memory spikes at night, explains the underlying JVM memory layout, shows how to trace the problem with heap dumps and monitoring data, and offers practical tips to avoid similar issues in Java applications.

HumongousObjectJVMMemoryLeak
0 likes · 41 min read
Why G1’s Humongous Objects Trigger Midnight Old‑Gen Spikes and How to Diagnose Them
Code Ape Tech Column
Code Ape Tech Column
Dec 31, 2023 · Backend Development

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

This article explains how to estimate capacity, choose appropriate garbage collectors, and configure JVM memory settings—including heap size, young generation, thread stack, and GC options—for a service that processes one million login requests per day on a node with 8 GB of RAM, providing step‑by‑step guidance and example command lines.

GC tuningJVMJava
0 likes · 25 min read
How to Set JVM Parameters for a Platform Handling 1 Million Daily Logins on an 8 GB Server
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Dec 31, 2023 · Operations

Master JDK Command-Line Tools for JVM Performance Tuning: A Practical Guide

This guide explores the JDK command‑line utilities located in %JAVA_HOME%\bin, explaining how tools such as jps, jstat, jinfo, jmap, jhat and jstack can be used to monitor JVM processes, analyze performance bottlenecks, inspect memory usage, generate heap dumps, and adjust runtime parameters for more efficient and stable Java applications.

JDKJVMJava
0 likes · 8 min read
Master JDK Command-Line Tools for JVM Performance Tuning: A Practical Guide
政采云技术
政采云技术
Dec 26, 2023 · Backend Development

Understanding Java Bytecode and Using ASM for Bytecode Manipulation

This article explains how Java achieves "write once, run anywhere" through platform‑independent bytecode, describes the .class file structure, introduces tools for viewing bytecode, and provides detailed guidance on using the ASM library’s Core and Tree APIs for bytecode enhancement, including practical code demos and application scenarios.

ASMBytecode ManipulationInstrumentation
0 likes · 16 min read
Understanding Java Bytecode and Using ASM for Bytecode Manipulation
Architecture Digest
Architecture Digest
Dec 15, 2023 · Operations

Diagnosing High CPU and Frequent GC in a Java Container: A Step‑by‑Step Analysis

When a production container suddenly hit over 90% CPU and excessive JVM garbage collection, the author walks through entering the pod, using top and top‑H to locate the offending thread, extracting its stack with jstack, downloading the data via a simple HTTP server, and ultimately discovering an Excel export routine that caused massive object allocation, fixing the code and restoring stability.

CPUJVMJava
0 likes · 6 min read
Diagnosing High CPU and Frequent GC in a Java Container: A Step‑by‑Step Analysis
JD Cloud Developers
JD Cloud Developers
Dec 13, 2023 · Backend Development

Resolving Unexpected 2‑Second Young GC Pauses in Java Rule Engine

A Java rule‑engine experiences occasional 1‑2 second Young GC pauses after warm‑up, caused by dynamic promotion thresholds that trigger massive object promotion, and the article explains the root cause, demonstrates log analysis, and provides JVM tuning steps to eliminate the long pauses.

Garbage CollectionJVMJava
0 likes · 15 min read
Resolving Unexpected 2‑Second Young GC Pauses in Java Rule Engine
DevOps Cloud Academy
DevOps Cloud Academy
Dec 11, 2023 · Operations

Managing Java Process Memory in Kubernetes Pods to Prevent OOMKilled

This article explains why Java processes in Kubernetes pods often encounter OOMKilled despite correct JVM heap settings, analyzes the discrepancy between JVM‑reported memory and container metrics, and provides practical steps such as adjusting MaxRAMPercentage and pod memory limits to stabilize memory usage.

JVMJavaKubernetes
0 likes · 9 min read
Managing Java Process Memory in Kubernetes Pods to Prevent OOMKilled
FunTester
FunTester
Dec 3, 2023 · Backend Development

Why Your Java App’s CPU Spikes: Mastering C1/C2 JIT Threads

This article explains how HotSpot's C1 and C2 JIT compiler threads work, why they can consume excessive CPU, and provides practical JVM tuning options—including tiered compilation, code‑cache sizing, and compiler‑thread adjustments—to mitigate performance issues.

C1C2HotSpot
0 likes · 11 min read
Why Your Java App’s CPU Spikes: Mastering C1/C2 JIT Threads
JD Retail Technology
JD Retail Technology
Nov 22, 2023 · Fundamentals

Understanding Java Class File Structure and JVM Execution Process

This article explains the Java class file format, including its magic number, version, constant pool, access flags, fields, methods, and attributes, and then details how the JVM loads, verifies, prepares, resolves, and initializes classes, manages object memory layout, and executes bytecode using a stack‑based interpreter.

JVMJavaMemoryManagement
0 likes · 21 min read
Understanding Java Class File Structure and JVM Execution Process