Garbage Collection (GC) is one of the most important responsibilities of the Java Virtual Machine (JVM).
As Java applications grow in complexity, managing memory efficiently becomes increasingly important. In enterprise applications, garbage collection can directly impact application response times, throughput, resource utilization, and overall system performance.
Modern Java provides multiple garbage collectors, but two important choices for server-side applications are:
- G1 Garbage Collector (G1 GC)
- Z Garbage Collector (ZGC)
Both collectors aim to manage memory efficiently, but they approach garbage collection differently.
So, which one should we choose for a production application?
Let's understand their architecture, working mechanisms, differences, and practical use cases.
1. Understanding G1 Garbage Collector
G1 stands for Garbage-First Garbage Collector.
It became the default garbage collector in Java 9 and is designed to provide a balance between application throughput and predictable garbage collection pauses.
Unlike traditional garbage collectors that divide the heap into large continuous memory areas, G1 divides the Java heap into multiple smaller regions.
Each region can dynamically belong to:
- Eden Space
- Survivor Space
- Old Generation
G1 prioritizes regions containing more reclaimable garbage, which is where its name comes from.
How G1 GC works
The G1 garbage collector follows several phases:
1. Young Generation Collection
- Collects objects from Eden and Survivor regions.
- Copies surviving objects into other regions.
- Reclaims unused regions.
- Uses Stop-The-World (STW) pauses.
2. Concurrent Marking
- Identifies live objects in the old generation.
- Performs significant marking work concurrently with application threads.
- Helps determine which old-generation regions contain reclaimable memory.
3. Mixed Garbage Collection
- Collects young-generation regions.
- Also collects selected old-generation regions.
- Prioritizes regions with more reclaimable space.
4. Full GC
- An expensive fallback operation.
- Can cause significantly longer application pauses.
- Ideally, production applications should avoid frequent Full GC events.
G1 GC architecture
Java Heap → Multiple Regions → Young Generation + Old Generation → Concurrent Marking → Mixed Collections → Memory Reclamation
The main advantage of G1 is its ability to balance throughput and pause-time goals without requiring extensive manual tuning.
2. Understanding Z Garbage Collector (ZGC)
ZGC is designed for applications where low latency is a major requirement.
Unlike G1, ZGC performs almost all expensive garbage collection work concurrently with application execution.
Its primary objective is to minimize application thread interruptions during garbage collection.
ZGC is particularly useful for applications that:
- Maintain large Java heaps.
- Require consistently low response times.
- Process high volumes of concurrent requests.
- Cannot tolerate significant GC-related latency spikes.
How ZGC works
ZGC uses several advanced JVM techniques:
1. Concurrent Marking
ZGC identifies live objects while application threads continue executing.
2. Concurrent Relocation
Live objects can be moved to new memory locations concurrently with application execution.
3. Load Barriers
ZGC uses load barriers to maintain correct object references when objects are relocated.
These mechanisms help the JVM manage references while garbage collection happens concurrently.
4. Reference Remapping
ZGC ensures that references to relocated objects are correctly resolved.
The application does not need to understand where objects physically reside in the heap.
ZGC architecture
Java Heap → Concurrent Marking → Live Object Identification → Concurrent Relocation → Reference Remapping → Memory Reclamation
Unlike G1, ZGC aims to keep Stop-The-World pauses extremely short, generally below one millisecond.
However, this does not mean the entire garbage collection cycle completes in one millisecond.
The majority of its work happens concurrently.
3. G1 GC vs ZGC: Key Differences
Let's compare both collectors.
| Feature | G1 GC | ZGC |
|---|---|---|
| Primary Goal | Balanced throughput and latency | Extremely low latency |
| Architecture | Region-based | Concurrent, region-based |
| Collection | Mostly concurrent | Almost entirely concurrent |
| STW Pauses | Usually longer than ZGC | Typically under 1 ms |
| Heap Support | Small to large heaps | Large heaps, up to 16 TB in supported configurations |
| Throughput | Generally strong | May involve additional CPU overhead |
| CPU Utilization | Moderate GC overhead | Can require more CPU resources |
| Configuration | Minimal tuning | Minimal tuning |
| Best For | General enterprise applications | Latency-sensitive applications |
Important: Actual performance depends on heap size, live data, allocation rate, CPU availability, and workload characteristics. Neither collector is universally faster.
4. Understanding Stop-The-World (STW) Pauses
One of the biggest differences between G1 and ZGC is how they handle application pauses.
What exactly is a Stop-The-World pause?
During certain garbage collection operations, the JVM temporarily pauses application threads to perform memory management safely.
Consider an online banking application.
Imagine an application processing thousands of payment requests per second.
If garbage collection pauses application threads for 200 milliseconds, some requests may experience additional latency.
This can impact:
- API response times
- Payment processing latency
- Transaction throughput
- Downstream service communication
- User experience
With G1, some garbage collection phases require Stop-The-World pauses.
With ZGC, most expensive operations happen concurrently, significantly reducing the time application threads are paused.
This makes ZGC particularly interesting for latency-sensitive backend services.
5. Real-World Example: Banking Microservices
Consider an enterprise banking platform built using:
- Java 21
- Spring Boot
- Microservices
- Apache Kafka
- PostgreSQL
- Redis
- Kubernetes / OpenShift
Imagine three services:
Account Service
- Handles account information.
- Processes balance inquiries.
- Supports regular transactional workloads.
Payment Service
- Processes payment requests.
- Handles transaction validations.
- Requires predictable API response times.
Fraud Detection Service
- Processes high-volume transaction events.
- Performs fraud analysis.
- Maintains significant amounts of in-memory data.
Which garbage collector should we choose?
| Service | Possible Choice | Reason |
|---|---|---|
| Account Service | G1 GC | Balanced throughput and latency |
| Payment Service | G1 or ZGC | Depends on strict latency requirements |
| Fraud Detection Service | ZGC | Worth evaluating for large heaps and latency-sensitive processing |
These are starting points, not fixed rules.
For example, if Payment Service experiences frequent GC-related latency spikes, ZGC may be worth evaluating.
However, switching to ZGC without profiling and benchmarking is not a recommended production strategy.
6. How to Enable G1 GC and ZGC
Let's look at the JVM options.
Enable G1 GC
java -XX:+UseG1GC -Xms4g -Xmx4g -jar application.jar Here:
-
-XX:+UseG1GCenables G1. -
-Xms4gsets the initial heap size. -
-Xmx4gsets the maximum heap size.
G1 is the default collector in modern HotSpot server configurations, so explicitly enabling it is usually unnecessary.
Enable ZGC
java -XX:+UseZGC -Xms4g -Xmx4g -jar application.jar This enables ZGC.
Important Java version consideration:
- Java 21 introduced Generational ZGC as an experimental feature. It can be enabled with
-XX:+UseZGC -XX:+ZGenerationalalong with the required experimental VM option. - Java 23 made Generational ZGC the default ZGC mode.
- Java 24 removed the non-generational ZGC mode. ZGC is generational by default.
This distinction is important when working with Java 21 versus newer Java releases.
7. Monitoring Garbage Collection
Choosing a garbage collector is only the first step.
Monitoring its behavior in production is equally important.
Enable GC logging:
-Xlog:gc*:file=gc.log:time,uptime,level,tags Monitor the following metrics:
- GC pause duration
- GC frequency
- Heap utilization
- Allocation rate
- Old-generation occupancy
- Concurrent GC activity
- CPU utilization
- Application response time
Useful monitoring tools include:
- Java Flight Recorder (JFR)
- Java Mission Control (JMC)
- VisualVM
- Prometheus
- Grafana
In Kubernetes or OpenShift environments, correlate JVM GC metrics with container CPU and memory utilization.
This helps identify whether performance issues are caused by garbage collection, application allocation patterns, CPU throttling, or insufficient memory limits.
8. When Should You Choose G1 GC?
Choose G1 when:
- Your application needs a balance between throughput and latency.
- GC pauses of tens or hundreds of milliseconds are acceptable for your workload.
- You run typical enterprise Spring Boot applications.
- You want a mature, general-purpose collector.
- Your current GC performance meets your production SLAs.
9. When Should You Choose ZGC?
Consider ZGC when:
- Your application has strict latency requirements.
- GC pauses are contributing to unacceptable p99 or p99.9 latency.
- Your application maintains a large live object set.
- You have sufficient CPU resources for concurrent GC operations.
- Benchmarking demonstrates measurable improvements over G1.
Remember: ZGC does not automatically fix memory leaks, excessive object allocation, or inefficient application code.
10. Final Thoughts
G1 GC and ZGC solve the same fundamental problem but optimize for different application requirements.
G1 GC is an excellent general-purpose choice for enterprise Java applications where throughput and predictable pauses need to be balanced.
ZGC is designed for workloads where minimizing garbage collection pauses is a critical requirement.
As Java developers and architects, understanding garbage collection is not just about JVM configuration.
It is about making informed architectural decisions that directly impact application performance, scalability, and reliability.
The best garbage collector is not necessarily the newest one. It is the one that meets your application's performance requirements under real production workloads.
Understand the workload. Measure the performance. Choose the collector.
References
Author: Ramu Boya | Ram The Architect (RTA)
Sharing practical Java, Spring Boot, Microservices, System Design, Cloud Architecture, and GenAI engineering insights.
Follow for more real-world Java and enterprise architecture discussions.
