How are memory shortages and OutOfMemoryError exceptions handled in Java?

Memory issues and OutOfMemoryError in Java are addressed through a comprehensive approach, including analyzing the source of the problem, optimizing code, and tuning JVM parameters.

Main causes of OutOfMemoryError:

1. Memory leaks.
2. Processing excessively large data volumes.
3. Suboptimal algorithms.
4. Incorrect JVM configuration.

Solutions:

1. Analyzing the cause of OutOfMemoryError

• Error message analysis: OutOfMemoryError often contains information about which memory area is overflowed (Heap, PermGen/Metaspace, Stack).
• Using profiling tools: JVM tools (VisualVM, JConsole, Mission Control), third-party profilers (YourKit, JProfiler). They allow:
  • Monitoring memory usage.
  • Analyzing heap dumps to identify objects occupying a lot of space.
  • Determining reference paths to objects to prevent their garbage collection.
• Logging: Adding logs to track memory consumption at key points in the application.

2. Code optimization

• Eliminating memory leaks:
  • Forgotten object references (e.g., in static fields, collections without clearing).
  • Improper use of external resources requiring closure (files, network connections, streams) - using try-with-resources.
  • Excessive use of caches without size or lifetime restrictions.
• Efficient use of collections: Choosing appropriate collection types, initializing them correctly (with initial capacity).
• Processing large data in parts: Instead of loading all data into memory, process it in fragments (streaming, pagination).
• Algorithm optimization: Using more efficient algorithms and data structures.
• Using primitive types instead of wrappers: Reduces object overhead.
• String Pool: Understanding and properly using String Pool to reduce string literal duplication.

3. JVM tuning

• Heap size: Configuring -Xms (initial heap size) and -Xmx (max heap size). Increasing these can temporarily solve the problem but does not address the underlying leak.
• Garbage Collector (GC):
  • Choosing the right GC (-XX:+UseG1GC, -XX:+UseParallelGC, -XX:+UseConcMarkSweepGC - deprecated, -XX:+UseZGC, -XX:+UseShenandoahGC).
  • Tuning GC parameters based on application characteristics (e.g., -XX:NewRatio, -XX:MaxGCPauseMillis).
  • Enabling GC logging (-Xlog:gc*=info:file=<gc.log>).
• PermGen / Metaspace size: In Java 8+, PermGen is replaced by Metaspace, which by default uses native memory. Parameters -XX:MaxMetaspaceSize, -XX:MetaspaceSize.
• Thread stack size: Configured with -Xss<size>. Reducing it can help if the problem is creating too many threads or deep recursion.

Example JVM flags:

# Set initial heap size to 512MB and max to 2GB
java -Xms512m -Xmx2g YourApplication

# Use G1 GC and enable GC logging
java -Xmx2g -XX:+UseG1GC -Xlog:gc*=info:file=gc.log YourApplication

4. Architectural solutions

• Load distribution: Using microservices architecture or distributed systems to reduce the data volume processed by a single process.
• External storage: Using databases, caches (Redis, Memcached), or file systems to store large data volumes instead of keeping them in application memory.

Resolving OutOfMemoryError always begins with identifying the cause. Without understanding what exactly causes memory overflow, any changes in code or configuration will be either temporary or ineffective.