Garbage Collection and Memory Management

Garbage Collection (GC) and Memory Management are critical aspects of Java’s runtime environment. Java automatically manages memory allocation and deallocation through its garbage collection mechanism, which helps developers avoid common memory-related issues like memory leaks and dangling pointers.

---

1. Java Memory Model

Java memory is divided into several regions:

1. Heap Memory:

• Stores objects and arrays.
• Divided into generations: Young Generation, Old Generation, and Permanent Generation (replaced by Metaspace in Java 8).

1. Stack Memory:

• Stores local variables and method call frames.
• Each thread has its own stack.

1. Metaspace (Java 8+):

• Stores class metadata, static variables, and method data.
• Replaces the Permanent Generation.

1. Native Memory:

• Used by the JVM for internal operations and native code.

---

2. Garbage Collection Overview

Garbage Collection is the process of reclaiming memory by identifying and deleting objects that are no longer in use. The JVM automatically performs garbage collection, but developers can influence it through JVM options and tuning.

Key Concepts

• Reachable Objects: Objects that are still referenced by the application.
• Unreachable Objects: Objects that are no longer referenced and can be garbage collected.
• Roots: Starting points for determining reachability (e.g., local variables, static fields).

---

3. Generational Garbage Collection

Java’s garbage collector divides the heap into generations to optimize performance:

1. Young Generation:

• Contains newly created objects.
• Divided into Eden Space and Survivor Spaces (S0 and S1).
• Minor GC (Young GC) collects garbage in the Young Generation.

1. Old Generation:

• Contains long-lived objects that have survived multiple GC cycles.
• Major GC (Full GC) collects garbage in the Old Generation.

1. Metaspace:

• Stores class metadata and is garbage collected separately.

---

4. Types of Garbage Collectors

Java provides several garbage collectors, each optimized for different use cases:

a. Serial GC

• Uses a single thread for garbage collection.
• Suitable for single-threaded applications or small heaps.
• Enabled with the JVM option: -XX:+UseSerialGC.

b. Parallel GC (Throughput GC)

• Uses multiple threads for garbage collection.
• Suitable for multi-threaded applications with medium to large heaps.
• Enabled with the JVM option: -XX:+UseParallelGC.

c. CMS (Concurrent Mark Sweep) GC

• Minimizes application pause times by performing most of the work concurrently.
• Deprecated in Java 9 and removed in Java 14.
• Enabled with the JVM option: -XX:+UseConcMarkSweepGC.

d. G1 (Garbage-First) GC

• Divides the heap into regions and prioritizes garbage collection in regions with the most garbage.
• Designed for applications with large heaps and low-latency requirements.
• Enabled with the JVM option: -XX:+UseG1GC.

e. ZGC (Z Garbage Collector)

• A low-latency garbage collector designed for very large heaps (up to terabytes).
• Introduced in Java 11.
• Enabled with the JVM option: -XX:+UseZGC.

f. Shenandoah GC

• A low-pause-time garbage collector that performs most of its work concurrently.
• Introduced in Java 12.
• Enabled with the JVM option: -XX:+UseShenandoahGC.

---

5. How Garbage Collection Works

1. Marking: Identify reachable and unreachable objects.
2. Sweeping: Remove unreachable objects.
3. Compacting: Move surviving objects to reduce fragmentation.

---

6. Monitoring and Tuning Garbage Collection

a. JVM Options for GC

• -Xmx: Maximum heap size.
• -Xms: Initial heap size.
• -XX:NewRatio: Ratio of Old Generation to Young Generation.
• -XX:SurvivorRatio: Ratio of Eden Space to Survivor Spaces.
• -XX:MaxGCPauseMillis: Target maximum pause time for GC (used by G1 and ZGC).

b. Tools for Monitoring GC

• jstat: Command-line tool for monitoring GC statistics.

  jstat -gc <pid>

• VisualVM: Graphical tool for monitoring JVM performance.
• GC Logs: Enable GC logging to analyze GC behavior.

  -Xlog:gc*:file=gc.log

---

7. Best Practices for Memory Management

1. Avoid Memory Leaks:

• Ensure objects are no longer referenced when no longer needed.
• Use tools like Eclipse Memory Analyzer (MAT) to detect memory leaks.

1. Minimize Object Creation:

• Reuse objects where possible (e.g., object pooling).

1. Tune GC Settings:

• Choose the appropriate garbage collector for your application.
• Adjust heap size and GC parameters based on application requirements.

1. Monitor Memory Usage:

• Regularly monitor memory usage and GC behavior to identify bottlenecks.

---

8. Example: Enabling GC Logging

To enable GC logging and analyze GC behavior, use the following JVM options:

java -Xlog:gc*:file=gc.log -Xmx512m -Xms256m MyApplication

---

9. Example: Using Weak References

Weak references allow objects to be garbage collected even if they are referenced. This is useful for caching.

import java.lang.ref.WeakReference;

public class WeakReferenceExample {
    public static void main(String[] args) {
        Object obj = new Object();
        WeakReference<Object> weakRef = new WeakReference<>(obj);

        obj = null; // Make the object eligible for GC

        System.gc(); // Suggest JVM to perform GC

        if (weakRef.get() == null) {
            System.out.println("Object has been garbage collected.");
        } else {
            System.out.println("Object is still alive.");
        }
    }
}

---

By understanding Garbage Collection and Memory Management in Java, you can optimize your application’s performance and avoid memory-related issues!