Boost Spring Boot Performance 3× with JVM Tuning: Practical Parameters

When your Spring Boot application responds slowly even after caching, database indexing, and asynchronous processing optimizations, the next place to look is the JVM itself.

Through profiling and deep investigation, I discovered that properly configuring JVM parameters can deliver a dramatic performance boost—up to 300% faster response under load—without any changes to the application code.

Actual JVM parameter configuration used

The principles behind these parameters

Benchmark comparison before and after optimization

Safe implementation methods for tuning

Benchmark: Where Is the Performance Bottleneck?

The application is a typical Spring Boot REST API that uses PostgreSQL and Hibernate ORM, handling CPU‑intensive JSON conversion and moderate‑intensity database queries.

Load testing was performed with wrk:

wrk -t4 -c100 -d30s http://localhost:8080/api/products

Pre‑Optimization Metrics

| Metric          | Value   |
| --------------- | ----------- |
| Average latency | 340 ms |
| Requests/sec    | ~280 req/s |
| 95% latency     | 500 ms |
| CPU usage       | ~80% |

Performance is acceptable under normal load, but latency spikes become unacceptable at production‑scale traffic.

Step 1: Enable G1 Garbage Collector

Spring Boot applications tend to consume a lot of memory, especially during JSON processing and Hibernate session handling. The G1 Garbage Collector is designed for applications that need large heaps and low pause times.

-XX:+UseG1GC

G1 divides the heap into multiple regions and collects them in parallel, effectively reducing "global pause" times.

Advanced Tuning: Reduce Latency

-XX:MaxGCPauseMillis=100
-XX:+ParallelRefProcEnabled

These flags aim to keep GC pauses under 100 ms and lower tail latency by processing references in parallel.

Step 2: Compress Class and Object Metadata

Reducing memory usage frees space for application data and lowers GC frequency.

-XX:+UseCompressedOops
-XX:+UseCompressedClassPointers

Most 64‑bit JVMs enable these by default; declaring them explicitly ensures consistency across environments.

Step 3: Adjust Thread Stack Size

Each thread defaults to a 1 MB stack. When an application creates hundreds of threads (e.g., DB connection pools, async workers), memory consumption rises sharply. -Xss256k Setting the stack size to 256 KB (validated safe by load testing) frees heap memory while avoiding stack overflow.

Step 4: Pre‑Allocate Memory at Startup

-XX:+AlwaysPreTouch

This forces the JVM to allocate the entire heap at startup, preventing runtime performance fluctuations caused by memory paging.

Step 5: Warm Up the JIT Compiler

JVM performance improves as the JIT compiler progressively optimizes hot code. The following flags accelerate this process:

-XX:+TieredCompilation
-XX:+UseStringDeduplication

String deduplication reduces memory duplication when handling large JSON payloads.

Full JVM Parameter List

Final optimized configuration:

-Xms2g
-Xmx2g
-Xss256k
-XX:+UseG1GC
-XX:MaxGCPauseMillis=100
-XX:+ParallelRefProcEnabled
-XX:+UseCompressedOops
-XX:+UseCompressedClassPointers
-XX:+AlwaysPreTouch
-XX:+TieredCompilation
-XX:+UseStringDeduplication

These can be set in application.properties or in the Dockerfile:

CMD ["java", "-jar", "-Xms2g", "-Xmx2g", "-XX:+UseG1GC", "-XX:MaxGCPauseMillis=100", ..., "app.jar"]

Post‑Optimization Performance

| Metric          | Value   |
| --------------- | ----------- |
| Average latency | **110 ms** |
| Requests/sec    | **850 req/s** |
| 95% latency     | **180 ms** |
| CPU usage       | ~90% |

Implementation Suggestions

Environment Compatibility Testing – JVM behavior may vary with workload and hardware.

Enable GC Logging – -Xlog:gc*:file=gc.log:time,uptime,level,tags Adjust heap size according to container memory limits or instance specs ( -Xms, -Xmx).

Conclusion

For production Spring Boot services, proper JVM tuning can unlock massive performance potential. Using the steps described, I achieved a three‑fold speed increase without touching any Java code.

Start with -XX:+UseG1GC and -XX:MaxGCPauseMillis=100, then add other parameters based on observed performance.

Remember: the JVM is not a black box. With the right tuning, this powerful machine can truly soar.