Java Memory Management: Heap, Stack, and Garbage Collection Tutorial

Java memory is divided into several areas, with the Heap and Stack being the most important for understanding memory management.

• Heap Memory:
  • Stores objects and their instance variables.
  • Shared among all threads in the application.
  • Memory is allocated dynamically during runtime.
  • Managed by the garbage collector.
• Stack Memory:
  • Stores local variables, method calls, and partial results.
  • Each thread has its own stack.
  • Memory is allocated in a Last-In-First-Out (LIFO) order.
  • Faster access compared to heap memory.

Edit Copy

public class Main {
    public static void main(String[] args) {
        int x = 10; // Stored in stack memory
        String str = new String("Hello"); // Object stored in heap, reference in stack
    }
}

The heap is the runtime data area where all Java objects are stored. It is divided into several generations for efficient memory management:

• Young Generation:
  • Where new objects are allocated.
  • Divided into Eden and Survivor spaces.
  • Frequent garbage collection occurs here (Minor GC).
• Old Generation:
  • Stores long-lived objects that have survived multiple garbage collection cycles.
  • Garbage collection here is less frequent (Major GC).
• Permanent Generation (Metaspace in Java 8+):
  • Stores metadata about classes and methods.
  • Replaced by Metaspace in Java 8, which uses native memory.

The stack is used for storing local variables and method call frames. Each thread has its own stack, which is created when the thread starts.

• Local Variables: Primitive types and object references are stored in stack memory.
• Method Calls: Each method call creates a new frame on the stack, which is removed when the method completes.
• Stack Overflow: Occurs when the stack runs out of memory, typically due to deep recursion.

Edit Copy

public class Main {
    public static void main(String[] args) {
        int x = 10; // Stored in stack memory
        String str = "Hello"; // Reference stored in stack, object in heap
        recursiveMethod(0); // May cause stack overflow
    }

    static void recursiveMethod(int i) {
        System.out.println(i);
        recursiveMethod(i + 1); // Recursive call
    }
}

Garbage collection is the process of automatically freeing up memory by removing objects that are no longer in use. Java's garbage collector runs in the background and manages heap memory.

• How GC Works:
  • Identifies objects that are no longer reachable (no references to them).
  • Reclaims memory by deleting these objects.
• Types of GC:
  • Minor GC: Cleans the young generation.
  • Major GC: Cleans the old generation.
  • Full GC: Cleans both the young and old generations.
• GC Algorithms:
  • Serial GC: Single-threaded, suitable for small applications.
  • Parallel GC: Multi-threaded, suitable for multi-core systems.
  • G1 GC: Designed for large heap sizes and low-latency applications.

To optimize memory usage and avoid memory leaks, follow these best practices:

• Minimize Object Creation: Reuse objects where possible to reduce garbage collection overhead.
• Use Primitive Types: Prefer primitive types over wrapper classes to save memory.
• Close Resources: Always close resources like files, sockets, and database connections to free up memory.
• Monitor Memory Usage: Use tools like VisualVM or JConsole to monitor memory usage and detect memory leaks.