Solving Memory Leaks in Spring Boot Applications: Profiling & Fixes

We recently deployed one of our Spring Boot applications to the AWS Cloud. Before the production release, we thoroughly tested everything in our QA and UAT environments — from functional and integration tests to performance and load testing.

Then came the big moment: production release day.

We deployed the application, started the services, routed the traffic, and received successful responses to our requests. Everything went according to plan. The whole team celebrated, and even our director congratulated us on the smooth launch. 🎉👏💐

But then… it happened.

Shortly after going live, our support team noticed anomalies on their Zabbix dashboard. It started with increased API response times, followed by timeouts, and finally… a flood of OutOfMemoryError (OOM) alerts.

🟣 The “Leaky Tank” Problem

Imagine your application’s memory like a water tank.

Everything seems fine — until a small, unnoticed leak causes it to overflow.

📉 Common Symptoms of a Memory Leak:

• ❌ Gradually increasing memory usage

• ❌ Slower and slower API responses

• ❌ Frequent garbage collection (GC) pauses

• ❌ And eventually… OutOfMemoryError crashes

For high-performance Spring Boot microservices handling thousands of requests per second, memory leaks can be devastating to stability and scalability.

🟣 What Causes Memory Leaks in Spring Boot?

1. ❌ Database connections not properly closed

2. ❌ Unbounded caches with no size or eviction strategy

3. ❌ Thread creation without limit (e.g., new Thread() everywhere)

4. ❌ Singleton beans holding references forever

5. ❌ InputStreams or file handles not closed

6. ❌ Event listeners still alive even after no longer in use

7. ❌ Static collections storing heavy objects

8. ❌ Session attributes storing large objects without expiration

🧪 How to Detect Memory Leaks

🔍 Useful Tools for Memory Profiling:

• Spring Boot Actuator – monitor memory and health endpoints

• VisualVM – heap analysis, GC monitoring, reference tracking

• Eclipse MAT (Memory Analyzer Tool) – deep heap dump analysis

• JProfiler / YourKit – advanced profiling tools

• Zabbix / Prometheus + Grafana – observability dashboards

💡 Pro tip: Enable heap dump generation on crash using -XX:+HeapDumpOnOutOfMemoryError

This lets you inspect the memory state at the exact moment the OOM happened.

🛠️ Fixing & Preventing Memory Leaks in Spring Boot

✅ Fix #1: Close Database Connections Properly

✔ Use try-with-resources to ensure auto-closing

✅ Fix #2: Control Cache Growth

✔ Use limited-size caches with eviction policies (e.g., Caffeine, Guava)

✅ Fix #3: Use Thread Pools Instead of Creating New Threads

✔ Prefer @Async, ExecutorService, or ThreadPoolTaskExecutor

✅ Fix #4: Use Appropriate Bean Scopes

❌ Singleton beans holding heavy data too long

✔ Use @RequestScope where applicable to reduce memory usage per request

✅ Fix #5: Close InputStreams Properly

✔ Always use try-with-resources to automatically close streams

✅ Fix #6: Avoid Static Collections Holding Heavy Objects

✔ Reconsider architecture if static objects store unbounded data

✅ Fix #7: Watch What You Store in HTTP Sessions

✔ Avoid placing large objects in sessions that never expire

🧰 Best Practices for Memory Optimization in Production

• ✔ Enable GC logging: -Xlog:gc*

• ✔ Set proper container memory limits: -Xmx, -Xms

• ✔ Use GraalVM Native Image for lightweight execution

• ✔ Add memory and GC alerts to your monitoring stack

• ✔ Include memory profiling in your CI/CD stress testing

🔮 Final Thoughts

Memory leaks are silent killers. They often go undetected in QA/UAT and only show up under real-world production loads. That’s why observability, good coding practices, and proactive monitoring are key to running stable services.

✅ A high-performance system is not only fast but reliable, efficient, and scalable over time.

Have you checked your memory health today?