BestHub
Sign in
Tagged articles
1029 articles
Page 5 of 11
Selected Java Interview Questions
Selected Java Interview Questions
Mar 5, 2023 · Backend Development

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

This article walks through a systematic approach to sizing and configuring JVM memory and garbage‑collector parameters for a service handling one million login requests per day on an 8 GB server, covering capacity planning, GC selection, heap region sizing, thread‑stack settings, dynamic age thresholds, large‑object handling, and diagnostic options such as heap dumps and GC logging.

Garbage CollectionJVMMemory Management
0 likes · 23 min read
JVM Parameter Tuning for a Platform with 1 Million Daily Login Requests on an 8 GB Node
Selected Java Interview Questions
Selected Java Interview Questions
Mar 4, 2023 · Backend Development

Analyzing the Performance Impact of try-catch in Java

This article investigates the common belief that using try-catch in Java severely degrades performance by examining JVM exception handling, bytecode generation, compilation optimizations, and extensive benchmark tests, ultimately showing that the overhead is negligible in most scenarios.

Exception HandlingJVMbenchmark
0 likes · 16 min read
Analyzing the Performance Impact of try-catch in Java
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Mar 3, 2023 · Mobile Development

Understanding Java Object Locks and Their Implementation in the Android Runtime (ART)

The article explains how Java’s synchronized keyword works by describing instance, static and block locks, the monitor‑enter/exit bytecodes, the ART object header’s lock word states (thin, fat, hash, forwarding), lock inflation mechanisms, and the internal runtime functions that implement Object.wait(), notify() and related futex handling.

Android RuntimeJVMjava
0 likes · 13 min read
Understanding Java Object Locks and Their Implementation in the Android Runtime (ART)
macrozheng
macrozheng
Mar 2, 2023 · Backend Development

Does a try‑catch Inside a Java Loop Really Slow Down Your Code?

This article investigates whether placing a try‑catch block inside a Java for‑loop impacts performance, presenting JMH benchmarks, bytecode analysis, and insights from Effective Java to clarify common misconceptions and provide practical guidance on exception handling in performance‑critical code.

Effective JavaJVMjava
0 likes · 7 min read
Does a try‑catch Inside a Java Loop Really Slow Down Your Code?
Top Architect
Top Architect
Feb 28, 2023 · Fundamentals

JVM Lock Optimization, Escape Analysis, and Synchronization Elimination

This article explains how the JVM improves concurrency performance through lock optimization techniques such as spin locks, lock elimination, lock coarsening, and escape analysis, illustrating each concept with code examples and discussing related optimizations like stack allocation and scalar replacement.

Escape AnalysisJVMconcurrency
0 likes · 9 min read
JVM Lock Optimization, Escape Analysis, and Synchronization Elimination
JD Retail Technology
JD Retail Technology
Feb 23, 2023 · Operations

Understanding and Tuning JVM ParallelGCThreads and Related Memory Parameters

This article explains the trade‑off between throughput and pause time in JVM garbage collection, details how the ParallelGCThreads, ConcGCThreads, and CICompilerCount parameters are calculated and affect performance, presents experimental results, and provides concrete configuration recommendations for both on‑heap and off‑heap memory in containerized Java applications.

DockerJVMMemory Tuning
0 likes · 14 min read
Understanding and Tuning JVM ParallelGCThreads and Related Memory Parameters
JD Retail Technology
JD Retail Technology
Feb 21, 2023 · Fundamentals

Understanding Java Object Memory Layout, Monitor, and Synchronization Mechanisms

This article explains the JVM object memory layout—including object header, instance data, and alignment padding—details the structure of the Mark Word and Klass Word, describes how monitors and the synchronized keyword work at the bytecode level, and covers lock states, inflation, bias revocation, and spin optimizations with practical code examples.

JVMLockMonitor
0 likes · 20 min read
Understanding Java Object Memory Layout, Monitor, and Synchronization Mechanisms
37 Interactive Technology Team
37 Interactive Technology Team
Feb 20, 2023 · Fundamentals

Fundamentals of the JVM: HotSpot, JIT, Memory Areas, Garbage Collection, and Class Loading

The article explains how the HotSpot JVM executes Java by interpreting bytecode, using client or server JIT compilers to translate hot methods into native code, describes the five runtime memory areas, outlines major garbage‑collection algorithms and tuning options, and details the class‑loading process and hierarchical classloader model.

JITJVMMemory Management
0 likes · 24 min read
Fundamentals of the JVM: HotSpot, JIT, Memory Areas, Garbage Collection, and Class Loading
Open Source Linux
Open Source Linux
Feb 15, 2023 · Backend Development

Choosing Java Docker Base Images & JDKs: Optimize Shutdown, Memory, and DNS

This article explains how to select the proper base image (Alpine or Debian), decide between JDK and JRE, choose Oracle or OpenJDK, handle graceful shutdown signals in Docker, configure memory limits across JDK versions, manage DNS caching, and optionally compile Java applications to native binaries with GraalVM.

DNSDockerGraceful Shutdown
0 likes · 25 min read
Choosing Java Docker Base Images & JDKs: Optimize Shutdown, Memory, and DNS
Top Architect
Top Architect
Feb 7, 2023 · Fundamentals

Understanding Java Heavyweight Locks: ObjectMonitor vs AQS

This article explains the differences and similarities between Java's ObjectMonitor and the AbstractQueuedSynchronizer (AQS) implementations of heavyweight locks, covering their internal data structures, waiting queues, lock acquisition order, and how synchronized interacts with wait/notify mechanisms.

AQSJVMObjectMonitor
0 likes · 11 min read
Understanding Java Heavyweight Locks: ObjectMonitor vs AQS
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Feb 1, 2023 · Fundamentals

Understanding ZGC: The Next‑Generation Low‑Latency Java Garbage Collector

ZGC, the Z Garbage Collector introduced in JDK 11, is a low‑latency, region‑based JVM garbage collector that uses colored pointers, load barriers, and multi‑mapping to achieve sub‑10 ms pause times across heap sizes up to several terabytes, with concurrent marking, relocation, and three brief STW phases.

Garbage CollectionJVMLow latency
0 likes · 8 min read
Understanding ZGC: The Next‑Generation Low‑Latency Java Garbage Collector
Qunar Tech Salon
Qunar Tech Salon
Jan 31, 2023 · Operations

Root Cause Analysis and Mitigation of JVM GC‑Induced OOM and Memory Fragmentation in a Containerized Hotel Pricing Service

This article details how long JVM garbage‑collection pauses and glibc ptmalloc memory‑fragmentation caused container OOM kills in a hotel‑pricing system, and explains the step‑by‑step diagnosis, JVM tuning, Kubernetes health‑check adjustments, and the replacement of ptmalloc with jemalloc to eliminate the issue.

JVMKubernetesMemoryFragmentation
0 likes · 9 min read
Root Cause Analysis and Mitigation of JVM GC‑Induced OOM and Memory Fragmentation in a Containerized Hotel Pricing Service
Open Source Linux
Open Source Linux
Jan 17, 2023 · Backend Development

Why Your Java App Gets OOMKilled in Kubernetes and How to Fix It

This article explains why Java applications running in Kubernetes containers are often terminated with OOMKilled (exit code 137), analyzes the underlying JVM memory‑limit mismatches, and provides practical solutions using cgroup‑aware JVM flags and memory‑tuning techniques.

DockerJVMKubernetes
0 likes · 14 min read
Why Your Java App Gets OOMKilled in Kubernetes and How to Fix It
Alibaba Cloud Native
Alibaba Cloud Native
Jan 16, 2023 · Cloud Native

Why Java Attach Fails on PID 1 in Containers and How to Fix It

The article reproduces the AttachNotSupportedException when Java runs as PID 1 in a container, explains the JVM attach workflow and LinuxThread model, and provides practical workarounds such as creating .attach_pid files, enabling StartAttachListener, or using newer JDK images.

ArthasAttachCloud Native
0 likes · 11 min read
Why Java Attach Fails on PID 1 in Containers and How to Fix It
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 16, 2023 · Backend Development

Unlock Non‑Spring AOP with JVM‑Sandbox: A Practical Guide for Java Backend

JVM‑Sandbox provides a non‑intrusive, runtime AOP solution for Java backend applications, enabling developers to instrument code outside the Spring container, record traffic, hot‑fix vulnerabilities, simulate failures, and monitor Spring bean initialization, all through JVMTI, Instrumentation, and event‑driven modules.

InstrumentationJVMaop
0 likes · 17 min read
Unlock Non‑Spring AOP with JVM‑Sandbox: A Practical Guide for Java Backend
Alibaba Cloud Native
Alibaba Cloud Native
Jan 14, 2023 · Cloud Native

Why Java Apps OOM in Kubernetes Even Below Xmx and How to Fix It

This article explains why Java applications running in Kubernetes can encounter Out‑Of‑Memory errors despite heap usage staying under the Xmx limit, by examining container resource limits, JVM memory models, cgroup behavior, and provides practical configuration recommendations to prevent OOM.

Cloud NativeJVMKubernetes
0 likes · 16 min read
Why Java Apps OOM in Kubernetes Even Below Xmx and How to Fix It
DeWu Technology
DeWu Technology
Jan 9, 2023 · Fundamentals

Understanding JVM Bytecode, JIT Compilation, and Garbage Collection

The article explains how the JVM executes Java bytecode, detailing bytecode structure, lambda compilation, JIT tiers and optimizations such as inlining and escape analysis, describes runtime memory areas and generational garbage collectors—including G1, ZGC, and Shenandoah—and offers key tuning flags for balancing throughput, latency, and heap size.

Garbage CollectionJITJVM
0 likes · 52 min read
Understanding JVM Bytecode, JIT Compilation, and Garbage Collection
Architect's Guide
Architect's Guide
Dec 29, 2022 · Fundamentals

Understanding Java Garbage Collection Algorithms and JVM GC Strategies

This article explains what constitutes garbage in the Java heap, compares reference‑counting and root‑reachability approaches, demonstrates a reference‑counting example, and reviews the main garbage‑collection algorithms and collectors (Serial, ParNew, Parallel Scavenge, Serial Old, Parallel Old, CMS, G1) used by modern JVMs.

G1GC AlgorithmsGarbage Collection
0 likes · 19 min read
Understanding Java Garbage Collection Algorithms and JVM GC Strategies
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 23, 2022 · Fundamentals

Four JVM Garbage Collection Algorithms Explained

This article introduces the four main JVM garbage collection algorithms—Mark‑Sweep, Copying, Mark‑Compact, and Generational collection—explaining their mechanisms, suitable scenarios, advantages, and drawbacks, and summarizing how they are applied to young and old generations in modern Java virtual machines.

CopyingGarbage CollectionGenerational GC
0 likes · 7 min read
Four JVM Garbage Collection Algorithms Explained
Code Ape Tech Column
Code Ape Tech Column
Dec 12, 2022 · Fundamentals

JVM GC Log Analysis and Tuning Practice

This article explains how to enable detailed GC logging in the JVM, interpret both Young and Full GC log entries, configure heap parameters, and use the online visualizer gceasy.io to analyze performance metrics such as throughput, pause latency, and memory usage for effective JVM tuning.

JVMTuninggc
0 likes · 9 min read
JVM GC Log Analysis and Tuning Practice
Sanyou's Java Diary
Sanyou's Java Diary
Dec 1, 2022 · Fundamentals

Mastering JVM Memory: From Heap to Metaspace and Beyond

This article provides a comprehensive overview of the Java Virtual Machine memory architecture, covering heap layout, object allocation, Metaspace, stack frames, native method stacks, program counters, direct memory, and code cache, complete with configuration tips and practical code examples.

Garbage CollectionHeapJVM
0 likes · 18 min read
Mastering JVM Memory: From Heap to Metaspace and Beyond
Youzan Coder
Youzan Coder
Nov 28, 2022 · Backend Development

How Switching from CMS to G1 Boosted Java Service Stability and Cut Costs

The article details how a Java team diagnosed frequent Full GC pauses caused by CMS, migrated to G1GC, adjusted JVM flags, scaled container specs, and achieved dramatically lower pause times, reduced instance counts, and significant cost savings while improving overall service stability.

BackendCMSJVM
0 likes · 13 min read
How Switching from CMS to G1 Boosted Java Service Stability and Cut Costs
Programmer DD
Programmer DD
Nov 10, 2022 · Backend Development

How to Choose the Right Java Base Image, JDK/JRE, and Optimize Container Settings

This guide walks through selecting Alpine or Debian base images, deciding between JDK and JRE, picking Oracle or OpenJDK, choosing the appropriate JVM, handling graceful shutdown signals, configuring memory limits across JDK versions, managing DNS cache, and leveraging GraalVM native compilation for Java containers.

DNSDockerJVM
0 likes · 22 min read
How to Choose the Right Java Base Image, JDK/JRE, and Optimize Container Settings
转转QA
转转QA
Nov 9, 2022 · Backend Development

Using JVM‑Sandbox for Exception Injection and Code Enhancement in Java Services

This article introduces JVM‑Sandbox, explains its non‑intrusive AOP capabilities, and provides a step‑by‑step tutorial on installing the sandbox, loading custom modules, performing code enhancement via instrumentation, and testing exception injection in a Java service.

Code EnhancementException InjectionInstrumentation
0 likes · 9 min read
Using JVM‑Sandbox for Exception Injection and Code Enhancement in Java Services
Tuanzi Tech Team
Tuanzi Tech Team
Oct 26, 2022 · Backend Development

Master JVM Performance: Memory Structures, Tuning Parameters, and Monitoring Tips

Explore comprehensive JVM performance optimization, covering memory architecture, key tuning flags, garbage collector selection, common OOM scenarios, and essential monitoring tools such as jstack, jstat, JConsole, and VisualVM, with practical examples and code snippets to help you diagnose and resolve memory issues.

Garbage CollectionJVMMemory Management
0 likes · 20 min read
Master JVM Performance: Memory Structures, Tuning Parameters, and Monitoring Tips
IT Architects Alliance
IT Architects Alliance
Sep 29, 2022 · Backend Development

Does Using try-catch in Java Significantly Impact Performance? An In-depth JVM Bytecode and JIT Analysis

Although a common belief claims that Java's try‑catch blocks severely degrade performance, this article dissects JVM exception handling, bytecode generation, and JIT/AOT optimizations, presents detailed test code and benchmarks, and demonstrates that when no exception occurs, the overhead is negligible.

JITJVMbytecode
0 likes · 17 min read
Does Using try-catch in Java Significantly Impact Performance? An In-depth JVM Bytecode and JIT Analysis
Architect
Architect
Sep 26, 2022 · Backend Development

Does Using try‑catch in Java Significantly Impact Performance? An In‑Depth JVM Analysis

This article investigates the common belief that Java's try‑catch blocks severely degrade performance by examining JVM exception handling mechanisms, analyzing compiled bytecode, and presenting extensive benchmark tests under various JVM compilation modes to determine the real impact of exception handling on execution speed.

Exception HandlingJITJVM
0 likes · 16 min read
Does Using try‑catch in Java Significantly Impact Performance? An In‑Depth JVM Analysis
Selected Java Interview Questions
Selected Java Interview Questions
Sep 23, 2022 · Backend Development

Diagnosing and Resolving a Native Memory Leak in Spring Boot Applications

This article details the investigation of an unexpected native memory consumption issue in a Spring Boot service, describing how JVM and system‑level tools were used to pinpoint the leak caused by the Spring Boot loader's Inflater usage and how configuring MCC scan paths or upgrading Spring Boot eliminated the problem.

JVMLinuxMemory Management
0 likes · 12 min read
Diagnosing and Resolving a Native Memory Leak in Spring Boot Applications
Alibaba Cloud Native
Alibaba Cloud Native
Sep 21, 2022 · Cloud Native

Why Continuous Profiling Is Essential for Cloud‑Native Java Applications

Continuous profiling (CP) bridges production and development by constantly feeding performance data back to developers, enabling on‑CPU and off‑CPU analysis, reducing overhead, and supporting tools like JFR and async‑profiler to diagnose CPU, memory, lock, and I/O bottlenecks in cloud‑native Java services.

JVMProfiling Toolsjava
0 likes · 20 min read
Why Continuous Profiling Is Essential for Cloud‑Native Java Applications
Code Ape Tech Column
Code Ape Tech Column
Sep 21, 2022 · Backend Development

Investigating Excessive Native Memory Usage in a Spring Boot Application Migrated to MDP Framework

After migrating a project to the MDP framework based on Spring Boot, the system repeatedly reported high swap usage despite a 4 GB heap configuration, leading to an investigation that uncovered native memory consumption caused by unchecked JAR scanning and allocator behavior, which was resolved by limiting scan paths and updating Spring Boot's inflater implementation.

JVMNative MemorySpring Boot
0 likes · 12 min read
Investigating Excessive Native Memory Usage in a Spring Boot Application Migrated to MDP Framework
Su San Talks Tech
Su San Talks Tech
Sep 17, 2022 · Fundamentals

Why Does Thread.sleep(0) Prevent GC? Uncovering JVM Safepoint Tricks

This article examines a puzzling 'prevent gc' comment in RocketMQ source, explains how inserting Thread.sleep(0) creates a JVM safepoint to avoid long GC pauses, explores counted vs uncounted loops, and demonstrates practical code modifications to improve performance.

Garbage CollectionJVMJava performance
0 likes · 13 min read
Why Does Thread.sleep(0) Prevent GC? Uncovering JVM Safepoint Tricks
vivo Internet Technology
vivo Internet Technology
Sep 14, 2022 · Backend Development

Performance Optimization Practices in Vivo Push Recommendation Service

The Vivo Push recommendation service was dramatically accelerated by replacing regex‑based String.split with a custom utility, converting massive String‑key maps to long keys, and moving large caches off‑heap, which together cut latency by about 32%, boosted throughput roughly 45% and nearly doubled overall performance.

Hotspot CodeJVMgc
0 likes · 15 min read
Performance Optimization Practices in Vivo Push Recommendation Service
Programmer DD
Programmer DD
Aug 29, 2022 · Backend Development

Does Java’s try‑catch Really Slow Down Your Code? A Deep Dive into JVM Performance

This article investigates the common belief that Java try‑catch blocks severely degrade performance by examining JVM exception handling mechanics, compiled bytecode, tiered and JIT compilation, and extensive benchmark tests, ultimately showing that try‑catch has negligible impact when no exception occurs.

Exception HandlingJVMbenchmark
0 likes · 18 min read
Does Java’s try‑catch Really Slow Down Your Code? A Deep Dive into JVM Performance
Top Architect
Top Architect
Aug 26, 2022 · Backend Development

Deep Dive into Java synchronized and Lock Mechanisms: Principles, JVM Internals, and Optimizations

This article explains thread safety in Java by detailing how the synchronized keyword and various Lock implementations work, covering their underlying JVM mechanisms, lock upgrade paths, optimizations like biased and lightweight locks, and practical differences between synchronized, ReentrantLock, and ReadWriteLock.

JVMLockReadWriteLock
0 likes · 19 min read
Deep Dive into Java synchronized and Lock Mechanisms: Principles, JVM Internals, and Optimizations
Sohu Tech Products
Sohu Tech Products
Aug 24, 2022 · Fundamentals

JVM JIT and CodeCache Parameter Configuration Guide

This article explains the JVM's Just‑In‑Time compilation mechanism and CodeCache memory area, detailing the purpose and default values of key JIT parameters such as TieredCompilation, CompileThreshold, OnStackReplacePercentage, CICompilerCount, as well as CodeCache settings like InitialCodeCacheSize, ReservedCodeCacheSize, Xmaxjitcodesize, CodeCacheMinimumFreeSpace and UseCodeCacheFlushing, and provides practical tuning advice for high‑traffic Java services.

CodeCacheHotSpotJIT
0 likes · 15 min read
JVM JIT and CodeCache Parameter Configuration Guide
Top Architect
Top Architect
Aug 23, 2022 · Backend Development

Understanding the Implementation of synchronized in Java and Its Differences with Lock

This article explains how Java's synchronized keyword works at the JVM level, detailing monitorenter/monitorexit bytecode, the role of object monitors, differences between synchronized methods and blocks, and compares its behavior and performance with explicit Lock implementations such as ReentrantLock, including code examples and practical considerations.

JVMLockReentrantLock
0 likes · 8 min read
Understanding the Implementation of synchronized in Java and Its Differences with Lock
Selected Java Interview Questions
Selected Java Interview Questions
Aug 22, 2022 · Backend Development

Understanding Java synchronized and Lock Mechanisms: From Basic Locks to Advanced Optimizations

This article explains Java thread‑safety concepts, the synchronized keyword, its underlying monitor implementation, lock‑upgrade stages, JVM optimizations such as lock elimination and coarsening, and compares explicit Lock interfaces like ReentrantLock and ReadWriteLock, helping developers choose the appropriate synchronization tool.

JVMLockReadWriteLock
0 likes · 16 min read
Understanding Java synchronized and Lock Mechanisms: From Basic Locks to Advanced Optimizations
IT Architects Alliance
IT Architects Alliance
Aug 16, 2022 · Backend Development

Seven Key Directions for Java Code Performance Optimization

This article theoretically outlines seven major Java performance optimization strategies—including reuse, computation, result set, resource conflict, algorithm, high‑efficiency implementation, and JVM tuning—explaining their principles, typical techniques, and how they collectively improve resource utilization and application speed.

JVMResource Managementbackend-development
0 likes · 11 min read
Seven Key Directions for Java Code Performance Optimization
政采云技术
政采云技术
Aug 9, 2022 · Backend Development

Handling Data Surge in a Data Push Platform: JVM Tuning, Flow Control, and Performance Optimization

This article analyzes the challenges of data‑burst scenarios in a data‑push platform, evaluates traditional throttling methods, presents JVM‑level tuning and a custom heap‑usage based flow‑control mechanism, and validates the solution through extensive pressure testing, demonstrating significant reductions in full GC frequency and overall push latency.

BackendFlow ControlJVM
0 likes · 22 min read
Handling Data Surge in a Data Push Platform: JVM Tuning, Flow Control, and Performance Optimization
Sohu Tech Products
Sohu Tech Products
Aug 3, 2022 · Backend Development

Understanding Java try‑catch‑finally Execution, Return Values, and Bytecode Mechanics

This article explains why static code analysis flags certain try‑catch‑finally patterns in Java, details the JVM's handling of exceptions and finally blocks, demonstrates how return values are determined at the bytecode level, and provides practical guidelines and a comprehensive reference of relevant bytecode instructions.

JVMbytecodetry-catch-finally
0 likes · 21 min read
Understanding Java try‑catch‑finally Execution, Return Values, and Bytecode Mechanics
ITPUB
ITPUB
Jul 31, 2022 · Fundamentals

What Really Happens Inside Java’s synchronized? A Deep Dive into JVM Lock Mechanisms

This article examines the inner workings of Java’s synchronized keyword by analyzing HotSpot 1.8 source code, revealing how lightweight, heavyweight, biased, and adaptive spin locks operate, how lock inflation occurs, and how the JVM manages monitor objects, CAS operations, and thread queues to implement synchronization.

JVMMonitorconcurrency
0 likes · 17 min read
What Really Happens Inside Java’s synchronized? A Deep Dive into JVM Lock Mechanisms
Selected Java Interview Questions
Selected Java Interview Questions
Jul 24, 2022 · Backend Development

Spring Boot Multi‑Environment Configuration and JVM Parameter Tuning Guide

This article demonstrates how to configure Spring Boot for multiple environments, retrieve custom parameters, package and run the application, modify startup settings via system variables or command‑line arguments, and explains the priority and detailed JVM options for optimizing a Spring Boot service.

ConfigurationJVMMulti-Environment
0 likes · 10 min read
Spring Boot Multi‑Environment Configuration and JVM Parameter Tuning Guide
Programmer DD
Programmer DD
Jul 21, 2022 · Fundamentals

Understanding JVM Memory Layout: Heap, Metaspace, and Stack Explained

This article explains the JVM memory layout, covering the heap area, its configurable size and generational structure, the Metaspace replacement for PermGen, the thread‑private virtual machine stack and native method stack, as well as the program counter register and related garbage‑collection behavior.

HeapJVMMetaspace
0 likes · 14 min read
Understanding JVM Memory Layout: Heap, Metaspace, and Stack Explained
21CTO
21CTO
Jul 19, 2022 · Fundamentals

Why Java Remains Dominant: Community, Ecosystem, and Future Trends

The article explores how Java has survived massive industry shifts through a vibrant community, extensive open‑source frameworks, continual language evolution, and emerging opportunities like WebAssembly, illustrating why it stays a cornerstone of enterprise and creative software development.

JVMProgramming Languagecommunity
0 likes · 8 min read
Why Java Remains Dominant: Community, Ecosystem, and Future Trends
Bin's Tech Cabin
Bin's Tech Cabin
Jul 8, 2022 · Backend Development

Graceful Shutdown in Java: From Kernel Signals to Netty, Spring & Dubbo

This article explores the complete lifecycle of graceful shutdown for Java server applications, detailing how operating‑system signals, JVM shutdown hooks, and framework‑level mechanisms in Spring, Dubbo, and Netty collaborate to safely stop services while preserving in‑flight requests and resources.

DubboGraceful ShutdownJVM
0 likes · 75 min read
Graceful Shutdown in Java: From Kernel Signals to Netty, Spring & Dubbo
Top Architect
Top Architect
Jul 4, 2022 · Fundamentals

Understanding JVM Class Loading, Memory Structure, and ClassLoader Mechanisms

This article provides a comprehensive overview of the JVM's memory layout, class loading subsystem, classloader categories, the parent‑delegation model, and custom classloader implementation, illustrating each concept with detailed explanations and code examples for Java developers.

JVMMemory Managementbytecode
0 likes · 19 min read
Understanding JVM Class Loading, Memory Structure, and ClassLoader Mechanisms
Selected Java Interview Questions
Selected Java Interview Questions
Jul 2, 2022 · Backend Development

Understanding Java String Constant Pool and the Behavior of String.intern() Across JDK Versions

This article explains the Java constant pool concept, details how the String constant pool works in different JDK versions, demonstrates the effects of String.intern() with code examples, and discusses practical applications and pitfalls of using intern for memory optimization and synchronization.

Constant PoolJVMMemory Optimization
0 likes · 16 min read
Understanding Java String Constant Pool and the Behavior of String.intern() Across JDK Versions
TAL Education Technology
TAL Education Technology
Jul 1, 2022 · Fundamentals

Why the JVM Can Run Cross‑Platform and an In‑Depth Look at Its Internal Architecture

This article explains how the Java Virtual Machine achieves write‑once‑run‑anywhere by abstracting platform differences, then details the JVM’s internal components—including the class‑loader subsystem, runtime data areas such as heap, stack, method area, and program counter—followed by code examples and analysis of object layout, pointer compression, and memory allocation strategies.

Garbage CollectionHeapJVM
0 likes · 30 min read
Why the JVM Can Run Cross‑Platform and an In‑Depth Look at Its Internal Architecture
Top Architect
Top Architect
Jun 24, 2022 · Fundamentals

Understanding JVM Memory Layout: Heap, Metaspace, Stacks, and Program Counter

This article explains the JVM memory architecture, covering the heap (young and old generations, Eden and Survivor spaces), Metaspace, virtual machine stacks, native method stacks, and the program counter register, while also illustrating key JVM parameters and bytecode execution with examples.

Garbage CollectionHeapJVM
0 likes · 13 min read
Understanding JVM Memory Layout: Heap, Metaspace, Stacks, and Program Counter
Alibaba Cloud Native
Alibaba Cloud Native
Jun 18, 2022 · Fundamentals

Unraveling Java Agent Crashes: JVM, glibc, and Thread‑Local Pitfalls

Starting from mysterious Java Agent errors in Alibaba Cloud environments, this article traces the failure through the JVM’s Instrumentation.appendToSystemClassLoaderSearch call, examines glibc’s stat and iconv conversions, reveals thread‑local storage issues, and presents concrete fixes using pthread TLS and proxy wrappers.

IConvJVMJava Agent
0 likes · 12 min read
Unraveling Java Agent Crashes: JVM, glibc, and Thread‑Local Pitfalls
Sanyou's Java Diary
Sanyou's Java Diary
Jun 3, 2022 · Fundamentals

Mastering JVM Garbage Collection: Interview Questions and Deep Dive

This article provides a comprehensive overview of JVM memory layout, explains major garbage‑collection algorithms and collectors, details how different memory regions cooperate, and offers practical tuning steps and tool usage for diagnosing GC issues in Java applications.

Garbage CollectionJVMJava performance
0 likes · 26 min read
Mastering JVM Garbage Collection: Interview Questions and Deep Dive
JavaEdge
JavaEdge
Jun 2, 2022 · Backend Development

How Does Java’s synchronized Work? A Deep Dive into Lock Mechanisms

This article simulates a Baidu interview to explain the underlying implementation of Java’s synchronized keyword, covering monitorenter/monitorexit bytecode, object header Mark Word, lock states, lock escalation from biased to heavyweight, and the role of CAS in lock acquisition and release.

JVMLockSynchronization
0 likes · 10 min read
How Does Java’s synchronized Work? A Deep Dive into Lock Mechanisms
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
May 26, 2022 · Backend Development

Investigation and Warm‑up Mitigation of JVM C2 CompilerThread CPU Spikes During Service Startup

The article details a real‑world case where JVM C2 CompilerThread CPU spikes during service startup caused request timeouts and GC pressure, explains how profiling identified the JIT compilation as the root cause, and describes a warm‑up replay strategy that pre‑compiles hotspot code to eliminate the spikes and stabilize deployments.

C2 CompilerThreadJITJVM
0 likes · 13 min read
Investigation and Warm‑up Mitigation of JVM C2 CompilerThread CPU Spikes During Service Startup
FunTester
FunTester
May 17, 2022 · Backend Development

Comprehensive Collection of Groovy Tutorials and Articles

This page provides an extensive curated list of Groovy tutorials covering introductions, environment setup, syntax basics, GString, keywords, traversal, regular expressions, integration with Java, Gradle, JMeter, operator overloading, closures, reflection, performance comparisons, and advanced scripting techniques for backend development.

BackendGradleGroovy
0 likes · 11 min read
Comprehensive Collection of Groovy Tutorials and Articles
Senior Brother's Insights
Senior Brother's Insights
May 15, 2022 · Backend Development

Top 50 Java Performance Tips to Supercharge Your Applications

This guide compiles fifty practical Java performance recommendations—ranging from judicious use of singletons and static variables to efficient collection handling, memory management, and low‑level optimizations like bit‑shifts and System.arraycopy—each illustrated with concise explanations and code snippets to help developers write faster, leaner Java code.

BackendJVMbest practices
0 likes · 24 min read
Top 50 Java Performance Tips to Supercharge Your Applications
21CTO
21CTO
May 13, 2022 · Backend Development

How Sonic Achieves Near‑Instant Hot Deployment for Java Services

This article details Meituan's internal Sonic IDEA plugin, explaining hot‑deployment concepts, why they matter, the technical challenges, and Sonic's architecture—including agents, instrumentation, class reloading, Spring Bean/XML/MyBatis reloads, and real‑world deployment experience—showing how code changes can become effective in seconds instead of minutes.

Hot DeploymentIDEA PluginInstrumentation
0 likes · 21 min read
How Sonic Achieves Near‑Instant Hot Deployment for Java Services
Top Architect
Top Architect
May 10, 2022 · Backend Development

Diagnosing Excessive Swap Usage in a SpringBoot Project: Memory Profiling and Native Memory Analysis

The article details a step‑by‑step investigation of a SpringBoot application that repeatedly triggered high swap usage, describing how JVM parameters, native memory tracking, gperftools, strace, and custom memory allocators were used to pinpoint and resolve off‑heap memory leaks caused by the Inflater implementation and glibc memory pools.

JVMNative MemorySpringBoot
0 likes · 12 min read
Diagnosing Excessive Swap Usage in a SpringBoot Project: Memory Profiling and Native Memory Analysis
Ops Development Stories
Ops Development Stories
Apr 20, 2022 · Fundamentals

Understanding ZGC: Low‑Latency Garbage Collection in Java

ZGC (Z Garbage Collector) is a scalable, low‑latency collector introduced in JDK 11, featuring sub‑millisecond pause times, region‑based memory layout, colored pointers, NUMA awareness, and concurrent phases, with detailed explanations of its architecture, parameters, triggers, and log analysis.

Garbage CollectionJVMLow latency
0 likes · 17 min read
Understanding ZGC: Low‑Latency Garbage Collection in Java
JD Tech
JD Tech
Apr 14, 2022 · Backend Development

JD.com Flash Sale Product Pool Expansion: Architecture Upgrade and Performance Optimization

This article details how JD.com tackled rapid growth of its flash‑sale product pool by analyzing JVM GC bottlenecks, redesigning the system architecture, introducing dual‑cache bucket updates, local LRU caching, Bloom filters, and service separation, ultimately achieving significant performance and stability improvements for large‑scale promotions.

Distributed SystemsGC optimizationJVM
0 likes · 12 min read
JD.com Flash Sale Product Pool Expansion: Architecture Upgrade and Performance Optimization
FunTester
FunTester
Apr 13, 2022 · Fundamentals

Why Groovy’s getTest Method Hijacks Your Static Calls – A Deep Dive

An in‑depth analysis reveals how Groovy’s implicit getter feature and method‑resolution rules cause a static method call to be intercepted by a subclass’s getTest method, leading to unexpected output and thread locking during performance testing.

GroovyInheritanceJVM
0 likes · 8 min read
Why Groovy’s getTest Method Hijacks Your Static Calls – A Deep Dive
Java Interview Crash Guide
Java Interview Crash Guide
Apr 8, 2022 · Backend Development

7 Core Strategies for Java Performance Optimization: Theory Overview

This article provides a theoretical overview of seven major Java performance optimization techniques—including code reuse, computation parallelism, asynchronous processing, lazy loading, result set reduction, resource conflict handling, and JVM tuning—offering readers a comprehensive framework to understand and improve application efficiency.

JVMbackend-developmentjava
0 likes · 11 min read
7 Core Strategies for Java Performance Optimization: Theory Overview
Senior Brother's Insights
Senior Brother's Insights
Apr 7, 2022 · Backend Development

7 Core Strategies to Supercharge Java Performance: Theory and Best Practices

This article presents a theoretical overview of seven major Java performance‑optimization directions—including reuse, parallel execution, async conversion, result‑set trimming, resource‑conflict handling, algorithm tuning, and JVM tuning—explaining their principles, typical techniques, and practical considerations for developers.

JVMbackend-developmentjava
0 likes · 14 min read
7 Core Strategies to Supercharge Java Performance: Theory and Best Practices
Ops Development Stories
Ops Development Stories
Mar 28, 2022 · Fundamentals

How Java Creates Objects: From Memory Allocation to Object Layout

This article explains the complete lifecycle of Java object creation, covering the JVM's handling of the new bytecode, class loading, memory allocation strategies such as pointer bumping and free lists, object header structure, layout, and tools for inspecting object memory.

Garbage CollectionJVMObject Layout
0 likes · 13 min read
How Java Creates Objects: From Memory Allocation to Object Layout
vivo Internet Technology
vivo Internet Technology
Mar 16, 2022 · Fundamentals

Dynamic Class Loading Practice in Java: Solving Extensibility Challenges in List Management System

The article shows how to overcome extensibility limits in a Java list‑management system by creating a custom DynamicClassLoader that loads encrypted .class files at runtime, explains Java’s class‑loading stages, fixes a Tomcat deployment issue via proper parent delegation, and demonstrates dynamic invocation of new encryption modules without code changes.

Code ExtensibilityDynamic LoadingJVM
0 likes · 14 min read
Dynamic Class Loading Practice in Java: Solving Extensibility Challenges in List Management System
Programmer DD
Programmer DD
Mar 15, 2022 · Backend Development

Essential Java Books Every Backend Engineer Should Read

This guide highlights the most influential Java books—from core language fundamentals and JVM internals to concurrency and effective coding practices—explaining why each title is vital for building a solid backend development skill set.

JVMbackend-developmentconcurrency
0 likes · 8 min read
Essential Java Books Every Backend Engineer Should Read
政采云技术
政采云技术
Mar 15, 2022 · Fundamentals

Understanding Java Class Loading Mechanism and Runtime Data Areas

This article explains how the JVM loads and links class files, describes the five runtime data areas—including the Method Area, Heap, JVM Stacks, Program Counter, and Native Method Stack—and details the class‑loader hierarchy and the parent‑delegation model used during class loading.

JVMMemory ModelRuntime Data Areas
0 likes · 17 min read
Understanding Java Class Loading Mechanism and Runtime Data Areas
Code Ape Tech Column
Code Ape Tech Column
Mar 7, 2022 · Operations

Using JDK Built‑in Tools to Monitor and Diagnose the JVM

This article demonstrates how to use the JDK’s native command‑line and graphical utilities—such as jps, jinfo, jvisualvm, jconsole, jstat, jstack and jcmd—to observe JVM metrics, troubleshoot memory and thread issues, and verify JVM parameters in Java applications.

JDKJVMjava
0 likes · 15 min read
Using JDK Built‑in Tools to Monitor and Diagnose the JVM