Memory in Java

🧠 Memory Management in Java - Complete Guide

Memory management in Java is a crucial aspect that ensures efficient use of memory and system resources. Java uses an automatic memory management model, mainly relying on the Java Virtual Machine (JVM) and Garbage Collector (GC) to manage memory allocation and deallocation. Below is a detailed explanation covering:

---

🔶 1. Types of Memory in Java

Java divides memory into several areas, each serving a different purpose. These are part of the Runtime Data Areas defined by the JVM specification.

✅ 1.1 Heap Memory

• Purpose: Stores objects and class instances.
• Managed by: Garbage Collector.
• Subdivided into:
  • Young Generation:
    • Eden Space: New objects are allocated here.
    • Survivor Spaces (S0, S1): Surviving objects move here after GC.
  • Old Generation: Holds long-lived objects. GC here is less frequent but more time-consuming.

✅ 1.2 Stack Memory

• Purpose: Stores method frames, local variables, and function calls.
• Each thread has its own stack.
• Memory follows LIFO order (Last-In-First-Out).
• Fast access but limited in size.

✅ 1.3 Method Area (MetaSpace in Java 8+)

• Stores class metadata, static variables, and method/field information.
• Known as PermGen in pre-Java 8.

✅ 1.4 Program Counter (PC) Register

• Each thread has its own PC register.
• Holds address of the current executing instruction.

✅ 1.5 Native Method Stack

• Used for native (non-Java) method calls.
• Supports native code execution via JNI.

---

🔶 2. Memory Allocation in Java

✅ 2.1 Static Memory Allocation

• Occurs at compile-time.
• Example: static variables.

✅ 2.2 Dynamic Memory Allocation

• Happens at runtime using new keyword.
• Allocated in the heap.

---

🔶 3. Garbage Collection (GC)

GC automates memory cleanup by removing unused objects from the heap.

✅ 3.1 How GC Works

• Unreferenced objects are marked as garbage.
• GC reclaims this memory.
• May cause program pause (stop-the-world events).

✅ 3.2 Types of Garbage Collectors

• Serial GC: Single-threaded; suitable for small apps.
• Parallel GC: Multi-threaded; high throughput.
• CMS: Reduces GC pause time.
• G1: Balanced; default in Java 9+.
• ZGC, Shenandoah: Low pause and scalable (Java 11+).

---

🔶 4. JVM Memory Structure Summary

Memory Area	Stores	Thread-Specific
Heap	Objects, class instances	No
Stack	Method calls, local variables	Yes
Method Area	Class metadata, static data	No
PC Register	Current instruction address	Yes
Native Method Stack	Native method data	Yes

---

🔶 5. Memory Leaks in Java

Even with GC, memory leaks can occur due to:

• Unintentional object retention (e.g., static maps, event listeners).
• Unbounded collections or caches.
• Unclosed resources (files, sockets).

🔍 Detection Tools

• VisualVM
• JProfiler
• Eclipse MAT (Memory Analyzer Tool)

---

🔶 6. Best Practices for Memory Management

• Choose suitable data structures (e.g., ArrayList vs LinkedList).
• Prevent memory leaks by:
  • Dereferencing unused objects.
  • Using try-with-resources for closing streams.
• Use WeakHashMap for cache structures.
• Profile memory usage often.
• Use flyweight design pattern when needed.

---

🔶 7. JVM Memory Tuning Parameters

Option	Description
-Xms<size>	Initial heap size
-Xmx<size>	Maximum heap size
-Xss<size>	Thread stack size
-XX:NewSize	Initial Young Gen size
-XX:MaxPermSize	Max PermGen size (pre Java 8)
-XX:MetaspaceSize	Initial Metaspace size (Java 8+)
-XX:+UseG1GC	Use G1 Garbage Collector

---

🔶 8. Real-World Example

public class MemoryExample {
    static int staticValue = 10;         // Stored in method area
    int instanceValue = 20;              // Stored in heap

    public void doWork() {
        int localValue = 30;             // Stored in stack
        String message = "Hello";        // String in heap (interned pool)
    }
}

---

🔶 9. Conclusion

Java memory management abstracts away manual memory handling through its JVM and garbage collection mechanism, making it safer and less error-prone than languages like C/C++. Still, understanding memory types and behavior is crucial for writing efficient and scalable Java applications.