How to fix an OutOfMemoryError in Java?

An OutOfMemoryError occurs when JVM exhausts memory; analyze error type (heap, metaspace, GC overhead, thread), increase heap size (-Xmx), check leaks via profilers and heap dumps, optimize object use, tune GC (e.g., G1GC), fix metaspace issues (-XX:MaxMetaspaceSize), and validate fixes.

An OutOfMemoryError in Java occurs when the JVM runs out of allocated memory and cannot allocate more. It's not a regular exception — it's an error, meaning something serious has gone wrong with memory management. Fixing it involves identifying the root cause and applying targeted solutions.

Analyze the Error Message

The first step is to read the exact message. Common variants include:

• Java heap space: The heap is full. Most common and usually fixable by adjusting heap size or fixing memory leaks.
• Metaspace: Metadata about classes (like loaded class definitions) uses too much space. Happens when many classes are dynamically loaded.
• GC Overhead limit exceeded: Garbage collector is running constantly but reclaiming little memory. Suggests inefficient memory use.
• Unable to create new native thread: Exhausted operating system resources for threads, not JVM heap.

Each message points to a different area needing attention.

Increase Heap Size (Quick Fix)

If your application genuinely needs more memory, adjust the JVM heap settings:

• -Xms512m — Set initial heap size.
• -Xmx2g — Set maximum heap size (e.g., 2 GB).

Example: java -Xms1g -Xmx4g MyApp

This doesn't fix memory leaks but may delay or avoid the error if the app just needs more room.

Check for Memory Leaks

A memory leak happens when objects are no longer needed but still referenced, preventing garbage collection. To detect one:

• Use a profiler like VisualVM, JConsole, or Eclipse MAT.
• Take heap dumps using jmap -dump:format=b,file=heap.hprof .
• Analyze the dump to find which objects consume the most memory and why they’re not collected.

Common culprits: static collections holding references, unclosed streams or connections, cached data without eviction.

Optimize Object Usage and Lifecycles

Reduce memory pressure by managing object creation and lifetime:

• Avoid creating unnecessary objects in loops.
• Use object pooling for expensive-to-create instances (e.g., database connections).
• Nullify references you no longer need (especially in long-lived objects).
• Prefer local variables over instance/static ones when possible.

Tune Garbage Collection

Different GC algorithms behave differently under load. Try switching or tuning:

• Use G1GC for large heaps: -XX: UseG1GC
• Enable GC logging: -Xlog:gc*:gc.log
• Analyze logs to see frequency and effectiveness of collections.

Sometimes, frequent full GCs indicate fragmentation or allocation rate issues.

Fix Metaspace Issues

If the error mentions Metaspace:

• Increase metaspace: -XX:MaxMetaspaceSize=512m
• Monitor class loading: Too many dynamically generated classes (e.g., via CGLIB, reflection) can fill it.
• Consider if you're redeploying apps repeatedly in containers — this can leak classloaders.

Basically, fixing an OutOfMemoryError means understanding where memory is going and deciding whether to scale up (more memory) or clean up (eliminate leaks, optimize usage). Always validate fixes with testing and monitoring.

The above is the detailed content of How to fix an OutOfMemoryError in Java?. For more information, please follow other related articles on the PHP Chinese website!