Что такое Out of Memory (OOM)?

Out of Memory (OOM) — is a situation where an application or operating system exhausts the available RAM to allocate new objects or perform required operations.

In the context of operating systems, OOM occurs when the system cannot allocate memory for a new process or thread. To prevent a complete system crash, Linux has the OOM Killer — a mechanism that forcibly terminates processes consuming a lot of memory to free resources.

In the context of applications, OOM occurs when the Java Virtual Machine (JVM) or other language runtime environment cannot allocate memory in the heap for creating a new object.

Causes of OOM can vary:

• Memory Leaks: Objects that are no longer used remain in memory because references to them prevent the garbage collector from deleting them.
• Excessive memory consumption: The application requests or holds too much memory for data processing (e.g., loading a large file entirely into memory).
• Insufficient memory allocation: JVM settings (e.g., -Xmx) or runtime environment configuration do not provide enough memory for the application to operate.
• Incorrect thread or connection pool configuration: Excessive number of active threads or connections can consume significant stack memory (for threads) or other memory areas.

Signs of OOM at the application level often include:

• Application slowdown.
• OutOfMemoryError exceptions in logs.
• Garbage Collector performance degradation.

To diagnose OOM, the following approaches are used:

• Log analysis: Search for OutOfMemoryError exceptions and OOM Killer messages.
• Heap dumps: Create a snapshot of heap contents at the moment of error for analysis using tools (e.g., Eclipse Memory Analyzer Tool (MAT), VisualVM).
• Monitoring: Use monitoring systems (Prometheus, Grafana, New Relic) to track JVM and OS memory usage.
• Profiling: Use profilers (JProfiler, YourKit) to identify memory usage patterns and leak sources.

// Example Java code that can lead to OOM (with memory leak)
import java.util.ArrayList;
import java.util.List;

public class OOMExample {
    private List<Object> largeList = new ArrayList<>();

    public void addObjects() {
        while (true) {
            largeList.add(new Object()); // Continuously adding objects without removing them
        }
    }

    public static void main(String[] args) {
        OOMExample example = new OOMExample();
        example.addObjects();
    }
}

# Example command to run Java with memory limit for quick OOM demonstration
java -Xmx64m OOMExample

Preventing OOM includes:

• Code optimization for efficient memory use.
• Proper JVM or runtime environment parameter configuration.
• Regular heap dump analysis and profiling.
• Monitoring memory usage in production.