OutOfMemoryError: Key Examples Explained

Understanding OutOfMemoryError

OutOfMemoryError is a common error encountered in Java applications when the Java Virtual Machine (JVM) cannot allocate an object due to insufficient memory. This can occur for various reasons, such as memory leaks, excessive memory consumption, or improper configuration of the JVM. In this article, we will explore three diverse examples of OutOfMemoryError to help you understand their causes and potential solutions.

Example 1: Memory Leak in a Web Application

Context

In a web application that uses a caching mechanism, the application retains user session data in memory. Without proper management, this can lead to memory leaks over time.

The application is designed to retain user data for quick access, but if the data is not cleared after the session expires, it will accumulate and eventually lead to an OutOfMemoryError.

Example

import java.util.HashMap;
import java.util.Map;

public class UserSessionCache {
    private static Map<String, String> sessionData = new HashMap<>();

    public static void addSessionData(String userId, String data) {
        sessionData.put(userId, data); // Data accumulates indefinitely
    }

    public static void main(String[] args) {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            addSessionData("user" + i, "Some data for user " + i);
        }
    }
}

Notes

• Solution: Implement a cleanup mechanism to remove expired sessions from the cache. Consider using a time-based expiration strategy.
• Variation: Using a third-party caching library like Ehcache can help manage memory more effectively.

Example 2: Large Array Allocation

Context

When working with large datasets, allocating a massive array in memory can lead to an OutOfMemoryError if the JVM heap size is not configured correctly.

In this scenario, a program attempts to read a large file and store it in memory as an array, which may exceed the available memory limits.

Example

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

public class LargeArrayExample {
    public static void main(String[] args) throws Exception {
        List<String> lines = Files.readAllLines(Paths.get("largefile.txt"));
        String[] data = new String[lines.size()]; // Potentially large allocation
        for (int i = 0; i < lines.size(); i++) {
            data[i] = lines.get(i);
        }
    }
}

Notes

• Solution: Consider processing the file in chunks or using streaming instead of loading the entire file into memory at once.
• Variation: Increase the JVM heap size with the -Xmx flag to allow larger allocations if necessary, but this is not a permanent solution.

Example 3: Infinite Recursion

Context

An infinite recursion scenario can occur when a method keeps calling itself without a proper termination condition, leading to a stack overflow and eventually an OutOfMemoryError.

This often happens in recursive algorithms if the base case is not defined correctly.

Example

public class InfiniteRecursionExample {
    public static void recursiveMethod() {
        // Missing a base case
        recursiveMethod(); // Calls itself indefinitely
    }

    public static void main(String[] args) {
        recursiveMethod();
    }
}

Notes

• Solution: Always ensure that recursive methods have a well-defined base case to prevent infinite recursion.
• Variation: Refactor the recursive logic into an iterative approach to avoid stack overflow issues altogether.