Table of Content

Chapter: Java Memory Management & Garbage Collection

JVM Memory Structure

Introduction to JVM

The Java Virtual Machine (JVM) is an essential Java Runtime Environment (JRE) component. It is responsible for running Java bytecode and converting it into machine code that your computer's processor can understand. When you compile a Java program, it is transformed into bytecode, stored in .class files, which the JVM then executes.

Memory Areas in JVM:

The JVM divides its memory into different sections, each with a specific purpose. Understanding these areas is crucial for managing memory effectively in Java applications.

• Heap Memory:

  • Definition: The Heap is the region where all Java objects are stored. Whenever you create an object using the new keyword, the JVM allocates space for this object in the Heap.

  • Characteristics:

    • The Heap is shared among all threads.
    • Objects in the Heap are globally accessible and referenced by various parts of the program.
    • Heap memory is dynamic and can grow as needed, but excessive usage can lead to memory shortages.

  • Example:

    public class Example {
        int data = 50;  // Instance variable stored in Heap
    
        public static void main(String[] args) {
            Example e1 = new Example();  // e1 points to an object in Heap
        }
    }
    
    

• Stack Memory:

  • Definition: Stack memory is where method calls, local variables, and references to objects in the Heap are stored. Each thread has its own stack memory, and it is used for execution purposes.

  • Characteristics:

    • Stack memory is limited in size and automatically managed (i.e., memory is allocated and deallocated as methods are called and return).
    • It stores references to objects in the Heap but not the objects themselves.
    • The Stack operates on a Last In, First Out (LIFO) principle.

  • Example:

    public void exampleMethod() {
        int x = 10;  // Local variable stored in Stack
        Example e = new Example();  // Reference stored in Stack, object in Heap
    }
    
    

• Metaspace:

  • Definition: Metaspace (formerly known as Permanent Generation or PermGen before Java 8) is where metadata about classes, methods, and other JVM internals are stored.
  • Characteristics:
    • Metaspace can grow dynamically, avoiding the memory limitations of the old PermGen space.
    • It contains information about class definitions and methods the JVM needs to execute your code.
  • Fun Fact: The transition from PermGen to Metaspace was introduced in Java 8 to handle the limitations of PermGen, such as frequent OutOfMemoryErrors when PermGen was exhausted.

Extra Knowledge:

• JVM Class Loader:
  • Definition: The class loader is responsible for loading class files into memory, verifying, preparing, and resolving them.
  • Types of Class Loaders:
    • Bootstrap Class Loader: Loads core Java libraries located in the <JAVA_HOME>/lib directory.
    • Extension Class Loader: Loads classes from the extension directories (<JAVA_HOME>/lib/ext).
    • Application Class Loader: Loads classes from the application classpath.

Garbage Collection in Java

Introduction:

Garbage Collection (GC) in Java is the process of automatically identifying and removing objects that are no longer in use, freeing up memory and preventing memory leaks.