BestHub
Sign in
Tagged articles
66 articles
Page 1 of 1
Ops Community
Ops Community
Mar 2, 2026 · Backend Development

How to Supercharge Tomcat 11 on JDK 21: Real‑World JVM, Connection Pool, and Virtual Thread Tuning

This guide walks you through practical performance tuning of Tomcat 11 on JDK 21, covering JVM memory settings, GC selection, connector and thread‑pool optimization, virtual‑thread integration, benchmark scripts, security hardening, high‑availability deployment, and comprehensive monitoring and troubleshooting techniques.

DockerJDK21JVM
0 likes · 51 min read
How to Supercharge Tomcat 11 on JDK 21: Real‑World JVM, Connection Pool, and Virtual Thread Tuning
ITPUB
ITPUB
Oct 18, 2025 · Backend Development

How We Eliminated GC Pauses in a 100k QPS Service: Deep Dive into JVM Tuning

This article details the step‑by‑step investigation and JVM‑level optimizations—including early tenuring, parameter tuning, ZGC migration, and an Eden‑pre‑heat trick—that transformed a high‑concurrency, low‑latency system from 95% to 99.995% success during massive index switches.

GC tuningJVMJava
0 likes · 22 min read
How We Eliminated GC Pauses in a 100k QPS Service: Deep Dive into JVM Tuning
Tech Freedom Circle
Tech Freedom Circle
Oct 12, 2025 · Backend Development

Understanding and Solving GC Spikes in High‑Throughput Java Services

The article explains what a GC spike (Garbage Collection Spike) is, analyzes its typical causes such as large short‑lived objects, memory leaks, and heap configuration, presents a real‑world high‑concurrency case study, and details step‑by‑step JVM tuning and architectural strategies that reduced latency spikes and raised service availability from 95% to over 99.99%.

Javag1gcgc
0 likes · 32 min read
Understanding and Solving GC Spikes in High‑Throughput Java Services
dbaplus Community
dbaplus Community
Sep 9, 2025 · Operations

How We Eliminated GC‑Induced Pauses in a 100k QPS Service

This article details a step‑by‑step investigation of a high‑concurrency, low‑latency system whose instability was traced to long‑lasting Young‑GC pauses during massive index swaps, and explains how targeted JVM parameter tweaks, GC‑log analysis, and a lightweight Eden‑pre‑heat technique finally achieved near‑perfect availability.

GC tuningJVMJava
0 likes · 22 min read
How We Eliminated GC‑Induced Pauses in a 100k QPS Service
Sanyou's Java Diary
Sanyou's Java Diary
Aug 28, 2025 · Backend Development

Unlocking JDK 17: Key Features, ZGC Benefits, and Upgrade Strategies

This article explores JDK 17's major language enhancements, new APIs, and performance‑focused improvements such as ZGC, then details Meituan's security‑team migration experience, performance benchmarks, practical upgrade steps, and JVM tuning tips for a smooth transition from JDK 8 to JDK 17.

Backend DevelopmentGarbage CollectionJDK 17
0 likes · 28 min read
Unlocking JDK 17: Key Features, ZGC Benefits, and Upgrade Strategies
Sanyou's Java Diary
Sanyou's Java Diary
Jul 24, 2025 · Backend Development

Why Upgrading to JDK 17 with ZGC Can Slash Costs and Boost Performance

This article explains how moving from Java 8 to JDK 17—leveraging new language features, updated APIs, and the ZGC garbage collector—can dramatically improve service latency, reduce GC pauses, lower machine costs, and enable AI SDKs that require Java 17, while also detailing migration steps and performance results.

GarbageCollectionJavaPerformancejdk17
0 likes · 31 min read
Why Upgrading to JDK 17 with ZGC Can Slash Costs and Boost Performance
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
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
Java Architecture Stack
Java Architecture Stack
Oct 30, 2024 · Operations

Why ZGC Is Revolutionizing Java Memory Management for Low‑Latency Apps

This article explains ZGC’s ultra‑low pause times, massive heap support, colored pointers, concurrent compaction, and generational optimizations, then shows how these features benefit real‑time analytics, high‑performance servers, and online transaction systems, and provides step‑by‑step instructions for enabling and tuning ZGC in Java.

Garbage CollectorJavaLow latency
0 likes · 9 min read
Why ZGC Is Revolutionizing Java Memory Management for Low‑Latency Apps
21CTO
21CTO
Aug 15, 2024 · Backend Development

What’s New in JDK 23? A Deep Dive into Upcoming Java Features

JDK 23, the next non‑LTS release of the Java platform slated for September 17, introduces a suite of preview features—including scoped values, structured concurrency, flexible constructor bodies, implicit class and instance methods, module import declarations, Markdown Javadoc, vector API enhancements, and a default generational ZGC mode—while deprecating sun.misc.Unsafe memory‑access methods.

JDK 23JavaScoped Values
0 likes · 11 min read
What’s New in JDK 23? A Deep Dive into Upcoming Java Features
High Availability Architecture
High Availability Architecture
Jun 27, 2024 · Backend Development

Understanding and Tuning Z Garbage Collector (ZGC) for Low‑Latency Java Applications

This article explains the principles, features, and workflow of Java's Z Garbage Collector, provides detailed configuration and logging guidance, and shares AutoMQ's practical tuning experiences that achieve sub‑millisecond pause times and improved performance for latency‑sensitive backend services.

AutoMQGarbage CollectionJava
0 likes · 26 min read
Understanding and Tuning Z Garbage Collector (ZGC) for Low‑Latency Java Applications
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
macrozheng
macrozheng
May 28, 2024 · Backend Development

Why Upgrading to JDK 17 with ZGC Can Slash GC Pauses to Sub‑millisecond

This article explains how moving to JDK 17 and the low‑latency ZGC garbage collector can reduce pause times to under 10 ms, improve throughput, and meet demanding real‑time service requirements, while providing practical upgrade steps, JVM tuning parameters, and performance comparisons.

Backend DevelopmentGarbage CollectionJava
0 likes · 8 min read
Why Upgrading to JDK 17 with ZGC Can Slash GC Pauses to Sub‑millisecond
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.

BackendGarbage CollectionJVM
0 likes · 6 min read
Upgrading to JDK 17 with ZGC: Performance Comparison and Migration Guide
JD Tech
JD Tech
Dec 5, 2023 · Backend Development

Comprehensive Guide to Upgrading from JDK8/11 to JDK17: Performance Benefits, New Language Features, and Migration Steps

This article explains why upgrading to JDK 17 is essential, outlines the long‑term support, performance gains from modern garbage collectors like ZGC, new language features such as switch expressions and records, and provides detailed migration steps, Maven and Spring Boot configuration, and troubleshooting tips for a smooth transition.

JDKSpringBootmaven
0 likes · 18 min read
Comprehensive Guide to Upgrading from JDK8/11 to JDK17: Performance Benefits, New Language Features, and Migration Steps
JD Cloud Developers
JD Cloud Developers
Nov 15, 2023 · Backend Development

Why Upgrade to JDK 17? Full Migration Guide from JDK 11 with Benchmarks

This article examines the benefits of moving from JDK 11 to the long‑term support JDK 17, detailing performance gains—especially sub‑millisecond ZGC pause times—new language features, compatibility considerations, benchmark results, and step‑by‑step migration instructions for Spring‑based applications.

JavaSpringBootjdk17
0 likes · 15 min read
Why Upgrade to JDK 17? Full Migration Guide from JDK 11 with Benchmarks
DeWu Technology
DeWu Technology
Sep 20, 2023 · Fundamentals

Understanding ZGC: Architecture, Key Features, and Execution Cycle

ZGC, introduced in JDK 11, is a non‑generational, highly concurrent Java garbage collector that uses colored pointers and load barriers to achieve sub‑10 ms pause times—even on terabyte‑scale heaps—while limiting throughput loss to under 15 % through three brief stop‑the‑world phases and four concurrent phases.

Garbage CollectionJVMconcurrency
0 likes · 17 min read
Understanding ZGC: Architecture, Key Features, and Execution Cycle
macrozheng
macrozheng
Sep 20, 2023 · Fundamentals

Why JDK 21’s Virtual Threads Could Revolutionize Java Concurrency

The article announces the official GA release of JDK 21, explains common version labels such as Alpha, Beta, RC and LTS, highlights the standout Virtual Threads feature requiring minimal code changes, and reviews the fifteen new JEPs across core libraries, language specifications, HotSpot and security enhancements.

JDK21JavaJavaFeatures
0 likes · 12 min read
Why JDK 21’s Virtual Threads Could Revolutionize Java Concurrency
JD Retail Technology
JD Retail Technology
Sep 14, 2023 · Backend Development

Root Cause Analysis of Memory Leak and High Latency in a Netty‑Based Real‑Time Risk Control System Using JDK 17 ZGC

This article investigates the severe memory growth and latency spikes observed when synchronizing data across data centers in a Netty‑driven online computation service, analyzes the impact of JDK 17 ZGC and direct‑buffer allocation, and presents the debugging steps, source‑code insights, and configuration changes that ultimately resolved the issue.

DirectMemoryJavaMemoryLeak
0 likes · 13 min read
Root Cause Analysis of Memory Leak and High Latency in a Netty‑Based Real‑Time Risk Control System Using JDK 17 ZGC
JD Tech
JD Tech
Sep 1, 2023 · Backend Development

JDK Upgrade Journey: From JDK 8 to JDK 17 with Performance Gains and GC Tuning

This article documents a comprehensive upgrade from JDK 8 to JDK 17, detailing new language and JVM features, evaluation criteria for selecting services, step‑by‑step migration of Maven settings, dependencies, SpringBoot and middleware, performance testing results, and ZGC‑focused garbage‑collector tuning.

JDKSpringBootgc
0 likes · 21 min read
JDK Upgrade Journey: From JDK 8 to JDK 17 with Performance Gains and GC Tuning
JD Cloud Developers
JD Cloud Developers
May 31, 2023 · Fundamentals

How Shenandoah and ZGC Achieve Sub‑10ms Pauses in Modern Java

This article compares the Shenandoah and ZGC garbage collectors introduced in OpenJDK, explaining their design goals, key differences from G1, core mechanisms such as connection matrices and forwarding or colored pointers, and detailing each collector’s concurrent phases to achieve pause times under 10 ms regardless of heap size.

Garbage CollectionJVMJava
0 likes · 16 min read
How Shenandoah and ZGC Achieve Sub‑10ms Pauses in Modern Java
JD Tech
JD Tech
Mar 16, 2023 · Fundamentals

A Comprehensive Overview of Java Garbage Collection Algorithms and ZGC

This article explains the fundamentals of Java garbage collection, detailing classic algorithms such as reference counting, reachability analysis, mark‑sweep, copying, mark‑compact, and generational collectors, then introduces modern collectors like Serial, Parallel, CMS, G1, and the low‑latency ZGC, highlighting their mechanisms, advantages, and drawbacks.

Garbage CollectionJVMMemory Management
0 likes · 27 min read
A Comprehensive Overview of Java Garbage Collection Algorithms and ZGC
Senior Brother's Insights
Senior Brother's Insights
Jun 26, 2022 · Backend Development

How ZGC Achieves Sub‑10 ms Pauses and Scalable Memory Management

This article explains ZGC’s evolution from an experimental feature in JDK 11 to a production‑ready collector in JDK 15, detailing its sub‑10 ms pause guarantee, memory‑mapping architecture, colored pointers, region layout, read barriers, and the multi‑phase concurrent collection process that together deliver low‑latency, high‑throughput garbage collection for Java applications.

Colored PointersConcurrent GCGarbage Collection
0 likes · 16 min read
How ZGC Achieves Sub‑10 ms Pauses and Scalable Memory Management
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 CollectionJVMJava
0 likes · 17 min read
Understanding ZGC: Low‑Latency Garbage Collection in Java
Programmer DD
Programmer DD
Mar 21, 2022 · Backend Development

Why Spring’s Bean Scanning Can Trigger Unresolvable Circular References (and How to Fix It)

This article examines how Spring Boot 2.0.3 resolves (or fails to resolve) setter‑based circular dependencies, explores bean definition scanning order, bean definition overriding, and instantiation sequence that can lead to an “unresolvable circular reference” error, and then shifts to explain ZGC’s mark‑compact algorithm, its evolution before and after JDK 16, and its performance characteristics.

bean-scanningcircular-dependencyjava-gc
0 likes · 14 min read
Why Spring’s Bean Scanning Can Trigger Unresolvable Circular References (and How to Fix It)
Tencent Cloud Middleware
Tencent Cloud Middleware
Jun 17, 2021 · Fundamentals

How Tencent Kona JDK 11 ZGC Delivers Millisecond‑Level GC Pauses for Real‑Time Services

Tencent's Kona JDK 11 introduces a production‑ready ZGC implementation that reduces Java garbage‑collection stop‑the‑world pauses to under 10 ms, enabling ultra‑low‑latency online services across massive heaps while maintaining acceptable throughput, and the article details its design, tuning, and real‑world deployments.

Garbage CollectionJava performanceLow latency
0 likes · 28 min read
How Tencent Kona JDK 11 ZGC Delivers Millisecond‑Level GC Pauses for Real‑Time Services
Java Backend Technology
Java Backend Technology
Mar 18, 2021 · Fundamentals

What’s New in JDK 16? 12 Game‑Changing Features Every Java Developer Should Know

JDK 16 introduces twelve major enhancements—including pattern‑matching instanceof, record classes, a highly concurrent ZGC, elastic metaspace, Unix‑domain sockets, a versatile jpackage tool, sealed classes, and a new vector API—providing Java developers with more concise code, better performance, and stronger encapsulation.

JDK16Javajpackage
0 likes · 9 min read
What’s New in JDK 16? 12 Game‑Changing Features Every Java Developer Should Know
Selected Java Interview Questions
Selected Java Interview Questions
Mar 11, 2021 · Fundamentals

Understanding ZGC: A Low‑Latency Garbage Collector for Java

The article explains ZGC, Oracle's low‑latency Java garbage collector introduced in JDK 11, covering its dynamic region layout, colored pointer technique, tri‑color marking, memory multi‑mapping, read barriers, operation phases, performance characteristics, and its main drawback of floating garbage.

Concurrent MarkingGarbage CollectionJava
0 likes · 11 min read
Understanding ZGC: A Low‑Latency Garbage Collector for Java
Big Data Technology Architecture
Big Data Technology Architecture
Mar 9, 2021 · Databases

Evaluating ZGC vs G1 GC Performance in HBase Clusters

This article examines the challenges of GC pauses in low‑latency HBase services, explains ZGC’s fully concurrent architecture and key techniques such as colored pointers and read barriers, and presents experimental comparisons of ZGC and G1 GC using YCSB benchmarks, highlighting latency, throughput and CPU usage differences.

Garbage CollectionHBaseYCSB
0 likes · 18 min read
Evaluating ZGC vs G1 GC Performance in HBase Clusters
Architect's Tech Stack
Architect's Tech Stack
Mar 1, 2021 · Backend Development

Detailed Overview of JDK 13 New Features and Enhancements

This article reviews the latest JDK 13 enhancements—including switch‑expression optimizations, text‑block syntax, dynamic AppCDS archives, ZGC memory‑reclamation, revamped socket APIs, new FileSystems methods, bulk ByteBuffer operations, the Reiwa era in java.time, expanded Unicode support, and recent HotSpot and security updates—providing code examples and migration guidance for Java developers.

AppCDSJDK13SwitchExpressions
0 likes · 11 min read
Detailed Overview of JDK 13 New Features and Enhancements
DataFunTalk
DataFunTalk
Feb 13, 2021 · Databases

Improving HBase Availability and Reducing Latency Spikes with Replication‑Based Multi‑Path Reads and ZGC

This article describes how the Didi HBase team tackled HBase’s weak availability and GC‑induced latency spikes by introducing a replication‑based client multi‑path read mechanism, configuring hedged reads, and adopting the Z Garbage Collector, and presents the resulting performance improvements and remaining challenges.

Big DataHBaseMulti-Path Read
0 likes · 11 min read
Improving HBase Availability and Reducing Latency Spikes with Replication‑Based Multi‑Path Reads and ZGC
Selected Java Interview Questions
Selected Java Interview Questions
Dec 23, 2020 · Backend Development

New Features in Java 16: A Comprehensive Overview

Java 16, scheduled for release in March 2021, introduces a range of enhancements such as sealed classes, stronger encapsulation, foreign‑memory access, pattern matching for instanceof, a new jpackage tool, ZGC improvements, Unix‑domain sockets, and expanded platform support, all aimed at improving security, performance, and developer productivity.

JDK 16JavaSealed Classes
0 likes · 8 min read
New Features in Java 16: A Comprehensive Overview
Top Architect
Top Architect
Dec 23, 2020 · Backend Development

New Features in JDK 16: Overview of Upcoming Java Enhancements

The article outlines the upcoming JDK 16 release, detailing new language and JVM features such as sealed classes, stronger encapsulation, foreign‑memory access, pattern matching for instanceof, Unix‑domain socket channels, ZGC improvements, jpackage support, and platform migrations to Windows/AArch64 and Alpine Linux.

JDK16New FeaturesSealed Classes
0 likes · 7 min read
New Features in JDK 16: Overview of Upcoming Java Enhancements
Didi Tech
Didi Tech
Dec 21, 2020 · Big Data

HBase Availability and Latency Optimizations: Replication‑Based Multi‑Read and ZGC Adoption

To overcome HBase’s weak availability and GC‑induced latency spikes, the DiDi team introduced a replication‑based client multi‑read (hedged‑read) mechanism and migrated to the Z Garbage Collector, which together dramatically cut maximum and 99.9th‑percentile latencies while keeping services online during region disruptions.

Big DataHBaseLow latency
0 likes · 12 min read
HBase Availability and Latency Optimizations: Replication‑Based Multi‑Read and ZGC Adoption
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 16, 2020 · Fundamentals

Exploring Modern Java Garbage Collectors: G1, ZGC, and Shenandoah

This article examines the evolution of Java garbage collectors, detailing the design and operation of G1, ZGC, and Shenandoah, and explains key concepts such as generational collection, write and read barriers, SATB, RSet, and multi‑view mapping with illustrative code and diagrams.

Concurrent AlgorithmsG1Garbage Collection
0 likes · 27 min read
Exploring Modern Java Garbage Collectors: G1, ZGC, and Shenandoah
Qunar Tech Salon
Qunar Tech Salon
Nov 13, 2020 · Fundamentals

Understanding JVM Garbage Collectors: Memory Models, Generational and Region-Based Designs, and Low‑Latency Collectors

This article examines the evolution and classification of HotSpot JVM garbage collectors, explaining the performance triangle of heap usage, throughput and pause time, and detailing generational, region‑based, and low‑latency collectors such as G1, Shenandoah, and ZGC with their design principles and benchmark results.

G1Garbage CollectionJVM
0 likes · 19 min read
Understanding JVM Garbage Collectors: Memory Models, Generational and Region-Based Designs, and Low‑Latency Collectors
macrozheng
macrozheng
Sep 25, 2020 · Backend Development

Master Java 15: Text Blocks, Records, Pattern Matching, Sealed Classes & ZGC

Explore the key Java 15 enhancements—including Text Blocks for effortless multiline strings, Records and local records for concise data models, Pattern Matching for streamlined type checks, Sealed Classes to control inheritance, and the low‑latency ZGC—plus practical IDE tips for using these features effectively.

JDK15JavaSealed Classes
0 likes · 9 min read
Master Java 15: Text Blocks, Records, Pattern Matching, Sealed Classes & ZGC
High Availability Architecture
High Availability Architecture
Aug 11, 2020 · Operations

Understanding and Optimizing ZGC (Z Garbage Collector) for Low‑Latency Java Services

This article examines the Z Garbage Collector (ZGC) introduced in JDK 11, detailing its low‑pause design goals, underlying concurrent marking‑copy algorithm, colored pointer and read‑barrier techniques, practical tuning parameters, real‑world case studies, and the performance impact of upgrading from CMS/G1 to ZGC in high‑throughput, low‑latency services.

Garbage CollectionJVMJava
0 likes · 28 min read
Understanding and Optimizing ZGC (Z Garbage Collector) for Low‑Latency Java Services
Meituan Technology Team
Meituan Technology Team
Aug 6, 2020 · Backend Development

ZGC: Principles, Tuning Practices, and Production Upgrade Experience

The article explains how Meituan’s risk‑control platform eliminated frequent 40 ms CMS pauses by adopting JDK 11’s ZGC—detailing its concurrent mark‑copy design, practical tuning parameters, real‑world case fixes, and measured latency reductions of up to 74 % while noting trade‑offs.

Garbage CollectionJDK11Java
0 likes · 27 min read
ZGC: Principles, Tuning Practices, and Production Upgrade Experience
Programmer DD
Programmer DD
Jun 13, 2020 · Fundamentals

Mastering Java Garbage Collection: Goals, Tuning, and Collector Choices

This article explains Java HotSpot VM garbage‑collection ergonomics, detailing pause‑time and throughput goals, generational collection mechanics, default heap sizing, and how to select and tune Serial, Parallel, G1, and ZGC collectors for optimal performance.

GC ErgonomicsGarbage CollectionJVM
0 likes · 32 min read
Mastering Java Garbage Collection: Goals, Tuning, and Collector Choices
Programmer DD
Programmer DD
May 22, 2020 · Backend Development

Can ZGC Deliver Sub‑10ms Pauses for Massive Java Heaps?

This article explains the design goals, architecture, key features, tuning options, and version history of Java's Z Garbage Collector (ZGC), highlighting its sub‑10 ms pause times for terabyte‑scale heaps, its use of colored pointers and load barriers, and the trade‑offs in throughput and configuration.

Garbage CollectionJVMJava
0 likes · 16 min read
Can ZGC Deliver Sub‑10ms Pauses for Massive Java Heaps?
Programmer DD
Programmer DD
Feb 23, 2020 · Backend Development

How to Replace the Deprecated CMS GC in JDK 9?

This article explains why the CMS garbage collector was removed in JDK 9, shows the deprecation warning, and evaluates three migration paths—switching to G1 GC, adopting ZGC, or continuing with CMS—helping developers choose the best option for their applications.

CMS GCGarbage CollectionJDK9
0 likes · 5 min read
How to Replace the Deprecated CMS GC in JDK 9?
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 11, 2019 · Backend Development

How Alibaba’s ElasticHeap, Wisp2, and ZGC Transform Java Performance for Cloud‑Native Apps

This article explains how Alibaba’s JVM team introduced ElasticHeap, static compilation, Wisp2 coroutines, feedback‑directed optimization, and ZGC to dramatically reduce Java heap usage, startup time, CPU load, and pause times, delivering cloud‑native performance improvements demonstrated during the Double‑11 traffic peak.

ElasticHeapJVMJava
0 likes · 11 min read
How Alibaba’s ElasticHeap, Wisp2, and ZGC Transform Java Performance for Cloud‑Native Apps
Java Captain
Java Captain
Oct 4, 2019 · Fundamentals

JDK 11‑13 Enhancements: Switch Expressions, Text Blocks, Dynamic CDS, ZGC Improvements, Socket API Rewrite, New FileSystem Methods, NIO Updates, Time API, I18N, and Feature Removals

This article summarizes the major JDK 11‑13 updates, including switch expression simplifications, multi‑line text block literals, dynamic AppCDS archives, ZGC memory‑release enhancements, a modernized socket API, new FileSystems methods, bulk NIO ByteBuffer operations, the Reiwa era in java.time, Unicode 12.1 support, and several deprecated features that have been removed.

Core LibraryJDKJava
0 likes · 10 min read
JDK 11‑13 Enhancements: Switch Expressions, Text Blocks, Dynamic CDS, ZGC Improvements, Socket API Rewrite, New FileSystem Methods, NIO Updates, Time API, I18N, and Feature Removals
21CTO
21CTO
Sep 17, 2019 · Backend Development

What’s New in Java 13? 5 Game‑Changing Features Explained

This article outlines Java 13’s release schedule, its five major JEPs—including Dynamic CDS Archives, ZGC memory uncommit, a revamped Socket API, Switch Expressions, and Text Blocks—detailing how each feature works, its usage steps, and sample code to help developers adopt them.

CDSJEPJava13
0 likes · 12 min read
What’s New in Java 13? 5 Game‑Changing Features Explained
Ctrip Technology
Ctrip Technology
Aug 28, 2019 · Fundamentals

Java Memory Layout and Garbage Collection Principles

This article provides a comprehensive overview of the JVM runtime memory areas, explains how the JVM determines garbage objects, reviews major GC algorithms and collectors—including the latest ZGC—and offers practical code examples and command‑line instructions for reproducing various OutOfMemoryError scenarios.

G1Garbage CollectionJVM
0 likes · 29 min read
Java Memory Layout and Garbage Collection Principles
Programmer DD
Programmer DD
Jul 3, 2019 · Backend Development

JDK 13: Dynamic CDS, ZGC Uncommit, Socket API, Switch Expressions, Text Blocks

JDK 13 introduces five notable enhancements—Dynamic CDS Archives for faster startup and lower memory use, ZGC’s ability to uncommit unused heap memory, a modernized socket API replacing legacy classes, preview switch expressions with both statement and expression forms, and preview text blocks for cleaner multi‑line strings.

DynamicCDSJDK13Java
0 likes · 10 min read
JDK 13: Dynamic CDS, ZGC Uncommit, Socket API, Switch Expressions, Text Blocks
Programmer DD
Programmer DD
Feb 12, 2019 · Fundamentals

How ZGC Achieves Sub‑10 ms Pauses: A Deep Dive into Java’s Low‑Latency GC

ZGC is a scalable, low‑latency Java garbage collector designed to keep pause times under 10 ms regardless of heap size, supporting up to 4 TB, and leveraging concurrent, region‑based, compacting, NUMA‑aware techniques, colored pointers, and load barriers, with detailed compilation and tuning guidance.

Garbage CollectionJDKJava
0 likes · 8 min read
How ZGC Achieves Sub‑10 ms Pauses: A Deep Dive into Java’s Low‑Latency GC
Programmer DD
Programmer DD
Sep 28, 2018 · Backend Development

Why Java 11 Is a Must‑Upgrade for Modern Enterprises

The article examines Java 11’s long‑term support status, key enhancements like ZGC, Flight Recorder, HTTP/2 client, TLS 1.3, and numerous JEPs, explaining why engineers and IT decision‑makers should consider upgrading to leverage performance, security, and productivity gains.

HTTP/2JDK 11JFR
0 likes · 11 min read
Why Java 11 Is a Must‑Upgrade for Modern Enterprises