Java Memory Leak Demo

Creating Memory Leaks in Java (and how to avoid them)

Java's garbage collection usually prevents memory leaks, but improper coding can circumvent it. For Java/Spring Boot developers, common culprits include:

1. Unclosed Resources: Failing to close InputStreams, OutputStreams, database connections, etc. keeps them in memory.

// BAD:  Resource not closed
InputStream is = new FileInputStream("file.txt");
// ...use is...

// GOOD:  Resource closed in finally block
try (InputStream is = new FileInputStream("file.txt")) {
    // ...use is...
} catch (IOException e) {
    //Handle exception
}

2. Static Collections: Storing large objects in static collections prevents garbage collection.

// BAD: Static list holds references indefinitely.
static List<LargeObject> largeObjects = new ArrayList<>();

// GOOD: Use a bounded collection or clear when appropriate.
List<LargeObject> largeObjects = new ArrayList<>(); // No static modifier
// ...later... largeObjects.clear();

3. Unreachable Objects: Objects referenced cyclically or via weak references might not be garbage collected. Consider using weak references judiciously.

4. Thread Locals: Data stored in ThreadLocal variables won't be garbage-collected until the thread dies. Ensure threads are properly managed.

5. Memory-intensive caching: Improper cache invalidation or unbounded caching can lead to huge memory consumption. Implement appropriate eviction strategies.

Preventing Leaks:

• Use try-with-resources: This ensures resources are closed automatically.
• Avoid static collections unless essential: Use them sparingly and manage their size.
• Profile your application: Tools like JProfiler or VisualVM help identify memory issues.
• Employ weak references cautiously: Understand their lifecycle and implications.
• Implement efficient caching strategies: Consider using bounded caches with appropriate eviction policies.

By understanding these common pitfalls and using best practices, Java/Spring Boot developers can avoid creating memory leaks and ensure application stability.