How Can I Deliberately Create a Memory Leak in Java?

How to Engineer a Memory Leak in Java

When asked to demonstrate memory leaks during an interview, it's understandable to feel puzzled. Here's how to craft a true memory leak with pure Java:

1. Establish a Persistent Thread: Create a thread that continuously runs or utilize a thread pool to accelerate the process.
2. Load a Custom Class: The thread loads a class using a custom ClassLoader (or a default one).
3. Create a Memory Object: Within the class, allocate a large memory chunk (e.g., new byte[1000000]) and store a strong reference to it in a static field. Additionally, store a reference to the class itself in a ThreadLocal.
4. Eliminate References: The application clears all references to the custom class or its ClassLoader.
5. Repeat the Process: Create multiple instances of this class, stacking them up in memory.

This approach exploits a limitation in ThreadLocal implementation. While each key in the threadLocals map is a weak reference that allows associated ThreadLocal objects to be garbage collected, the corresponding value holds a strong reference. If the value references the ThreadLocal object, a circular dependency is formed, preventing both entities from being garbage collected.

Ultimately, this creates a leak with strong references:

• Thread object → threadLocals map → Class instance → Static ThreadLocal field → ThreadLocal object.

ClassLoader also contributes to the leak by adding an extra reference chain:

• Class instance → ClassLoader → Loaded classes.

This pattern has led to severe memory leaks in application containers like Tomcat, where frequently redeploying applications using ThreadLocals creates hidden references.

The above is the detailed content of How Can I Deliberately Create a Memory Leak in Java?. For more information, please follow other related articles on the PHP Chinese website!