How would you detect and minimise memory leaks in Java?

In Java memory leaks are caused by poor program design where object references are long lived and the garbage

collector is unable to reclaim those objects.

Detecting memory leaks:

􀂃 Use tools like JProbe, OptimizeIt etc to detect memory leaks.

􀂃 Use operating system process monitors like task manager on NT systems, ps, vmstat, iostat, netstat etc on

UNIX systems.

􀂃 Write your own utility class with the help of totalMemory() and freeMemory() methods in the Java Runtime

class. Place these calls in your code strategically for pre and post memory recording where you suspect to be

causing memory leaks. An even better approach than a utility class is using dynamic proxies (Refer Q11 in

How would you go about section…) or Aspect Oriented Programming (AOP) for pre and post memory

recording where you have the control of activating memory measurement only when needed. (Refer Q3 – Q5

in Emerging Technologies/Frameworks section).

Minimising memory leaks:

In Java, typically memory leak occurs when an object of a longer lifecycle has a reference to objects of a short life cycle.

This prevents the objects with short life cycle being garbage collected. The developer must remember to remove the references

to the short-lived objects from the long-lived objects. Objects with the same life cycle do not cause any issues because the

garbage collector is smart enough to deal with the circular references (Refer Q33 in Java section).

􀂃 Design applications with an object’s life cycle in mind, instead of relying on the clever features of the JVM.

Letting go of the object’s reference in one’s own class as soon as possible can mitigate memory problems.

Example: myRef = null;

􀂃 Unreachable collection objects can magnify a memory leak problem. In Java it is easy to let go of an entire

collection by setting the root of the collection to null. The garbage collector will reclaim all the objects (unless

some objects are needed elsewhere).

􀂃 Use weak references (Refer Q32 in Java section) if you are the only one using it. The WeakHashMap is a

combination of HashMap and WeakReference. This class can be used for programming problems where you

need to have a HashMap of information, but you would like that information to be garbage collected if you are

the only one referencing it.