1. Memory Types in Java: Stack and Heap
Stack Memory:
-
Purpose: Stack memory is used to store temporary variables, method-specific data, and references to objects in the heap.
-
Characteristics:
- Stores Primitive Data Types: Primitive types like
int,char,boolean, etc., are stored directly on the stack. - Stores Object References: The stack stores references (pointers) to objects that reside in the heap, not the objects themselves.
- Method-Specific Storage: Each time a method is invoked, a new block (or frame) is pushed onto the stack, containing method parameters, local variables, and return addresses.
- Thread-Specific: Each thread has its own stack memory. Local variables in methods are thread-safe by default.
- LIFO Structure: The stack operates in a Last-In-First-Out (LIFO) manner. When a method finishes execution, its stack frame is popped off, and memory is reclaimed.
- Scope Bound: Variables within a method’s scope are only accessible while the method is in execution. Once the method completes, these variables are removed from the stack.
- Errors:
- StackOverflowError: Occurs when the stack memory limit is exceeded, often due to deep or infinite recursion.
- Stores Primitive Data Types: Primitive types like
-
Diagram:
Stack Memory (Thread 1) Heap Memory (Shared) +-----------------+ +----------------------+ | Method Call #3 | | +---------------+ | |-----------------| | | Object A | | | Local Variables | | +---------------+ | |-----------------| +--------------------> | | Field 1 | | | Primitive Data | | | | Field 2 | | |-----------------| | | +---------------+ | | Object Ref ---> |-----+ | | +-----------------+ | +---------------+ | +------------------> | | Object B | | +-----------------+ | | +---------------+ | | Method Call #2 | | | | Field 1 | | |-----------------| | | | Field 2 | | | Local Variables | | | +---------------+ | |-----------------| | | | | Primitive Data | | | | |-----------------| | | | | Object Ref ---> |-------+ | | +-----------------+ | | | | +-----------------+ | | | Method Call #1 | | | |-----------------| | | | Local Variables | | +---------------+ | |-----------------| +--------------------> | | Object C | | | Primitive Data | | | +---------------+ | |-----------------| | | | Field 1 | | | Object Ref ---> |-----+ | | Field 2 | | +-----------------+ | +---------------+ | +----------------------+
Heap Memory:
-
Purpose: Heap memory is used for dynamic memory allocation of Java objects and classes at runtime. It is shared among all threads.
-
Characteristics:
- Stores Objects: Unlike the stack, the heap is where actual objects are stored, including instance variables and arrays.
- No Specific Order: Objects can be allocated in any order in the heap. Memory allocation is dynamic and less organized than in the stack.
- Shared Access: Heap memory is shared among all threads, necessitating synchronization to avoid issues like race conditions.
- Garbage Collection: The heap is managed by the Garbage Collector, which reclaims memory by deleting objects that are no longer referenced.
- String Pool: Heap also contains the string pool, a special memory region used to store string literals.
- Division of Heap:
- Young Generation: Where new objects are allocated. It consists of:
- Eden Space: Most objects are created here initially.
- Survivor Spaces (S0 and S1): Objects that survive garbage collection in Eden are moved to the survivor spaces.
- Old Generation: Stores objects that have survived multiple garbage collections and are considered long-lived.
- Permanent Generation (or Metaspace in Java 8+): Stores class metadata and static variables.
- Young Generation: Where new objects are allocated. It consists of:
-
Errors:
- OutOfMemoryError: Occurs when the JVM runs out of memory in the heap and cannot allocate space for new objects, often due to memory leaks or simply running out of available heap space.
-
Diagram:
+-------------+ +-------------+ +-------------+ +-------------+ | Eden Space | | Survivor S0 | | Survivor S1 | | Old Gen | | (Young Gen) | | (Young Gen) | | (Young Gen) | | (Tenured) | +-------------+ +-------------+ +-------------+ +-------------+
2. Garbage Collection in Java
Role of Garbage Collector:
- The Garbage Collector (GC) is responsible for automatically managing memory in the heap. It identifies objects that are no longer in use (i.e., no longer referenced) and reclaims memory by deleting these objects.
Algorithms Used:
-
Mark and Sweep:
- Mark Phase: The GC starts at the root references and marks all reachable objects.
- Sweep Phase: The GC then sweeps through the heap, reclaiming memory from objects that were not marked as reachable.
- Compacting: Some GC implementations also perform compaction, which reorganizes the heap to reduce fragmentation and improve allocation efficiency.
-
Diagram:
[Mark Phase] Roots --> +---+ +---+ +---+ | A | ---> | B | ---> | C | +---+ +---+ +---+ | | v v +---+ +---+ | D | | E | +---+ +---+ [Sweep Phase] +---+---+---+---+---+---+ | | A | | B | | C | +---+---+---+---+---+---+ (Free) (Free) [Compacting] +---+---+---+---+---+---+ | A | B | C | | | | +---+---+---+---+---+---+
Types of Garbage Collectors:
- Serial GC: Uses a single thread for garbage collection, pausing all other threads during the process. Suitable for smaller applications where pause times are not critical.
- Parallel GC: Uses multiple threads to perform garbage collection in parallel, improving throughput on multi-core processors.
- CMS (Concurrent Mark-Sweep) GC: Minimizes pause times by performing most of the garbage collection work concurrently with the application threads. Suitable for applications requiring low-latency GC.
- G1 (Garbage First) GC: Divides the heap into regions and prioritizes the collection of regions with the most garbage. Designed for large heaps and low-pause times.
3. Important Points to Remember
Memory Management:
- Understanding the Difference: Knowing when variables are stored in the stack vs. the heap is crucial, especially for optimizing memory usage and understanding potential errors like
StackOverflowErrororOutOfMemoryError. - Scope and Lifetime: Variables in the stack are short-lived and exist only within the scope of a method, while objects in the heap persist as long as they are referenced by any part of the program.
Garbage Collection:
- GC Performance Tuning: Different GC algorithms have trade-offs between throughput and pause times. Choosing the right GC algorithm and tuning its parameters (
-Xms,-Xmx,-XX:+UseG1GC, etc.) is essential for optimizing application performance. - Memory Leaks: Despite GC, memory leaks can still occur if objects are unintentionally referenced, preventing GC from reclaiming their memory. Tools like JVisualVM or JConsole can help detect and diagnose memory leaks.
- GC Logs: Enabling and analyzing GC logs can provide insights into how garbage collection is impacting application performance and help identify bottlenecks or inefficiencies.
These explanations, accompanied by ASCII diagrams, should provide a clear and detailed understanding of Java memory management and garbage collection, aiding your preparation for an SDE-2 interview.