How would you structure your code to avoid memory leaks in a long-running application?

Question

Accepted Answer

Memory leaks in long-running applications occur when objects that are no longer required remain referenced, preventing the Garbage Collector from reclaiming memory. To avoid such issues, code should be designed with proper resource management, controlled object lifecycles, and regular monitoring of memory usage.

Key Points:
• Always release resources such as database connections, file streams, sockets, and threads when they are no longer needed.
• Avoid unnecessary static references, unbounded caches, and collections that continuously grow in size.
• Use WeakReference, WeakHashMap, and try-with-resources where appropriate to reduce the risk of retaining unused objects.

Example:
Suppose an application stores user sessions in a static HashMap but never removes expired sessions. Over time, the map keeps growing, consuming more memory and eventually causing performance issues or OutOfMemoryError.

Code Example:
```
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class ResourceExample {

public void readFile(String fileName)
            throws IOException {
```
        try (BufferedReader reader =
```
                     new BufferedReader(
                             new FileReader(fileName))) {

System.out.println(
                    reader.readLine());
        }
    }
}
```
Best Practices:
• Use try-with-resources for automatic resource cleanup.
• Remove unused objects from collections and caches.
• Deregister listeners, callbacks, and observers when no longer needed.
• Avoid storing large objects in static variables.
• Use bounded caches with eviction policies.
• Regularly monitor heap usage using tools such as VisualVM, JProfiler, MAT, or Java Flight Recorder.

Interview Tip:
A concise interview answer is: To avoid memory leaks in long-running applications, I ensure proper resource cleanup, avoid unnecessary object retention, use try-with-resources, manage caches carefully, remove obsolete references, and continuously monitor memory usage using profiling tools to detect leaks before they impact production systems.