Introduction

In the previous lesson, we explored Streams and Lambda Expressions, introducing functional programming for efficient data processing. This week, we dive into Memory Management in Java - a critical topic that helps you write performant and leak-free applications.

Stack vs. Heap Memory

Java memory is divided into two main areas:

• Stack Memory:

  Stores method calls, local variables, and references to objects in the heap. It operates in a Last-In-First-Out (LIFO) manner.

• Heap Memory: Stores objects and class instances. The garbage collector automatically manages memory allocation and deallocation here.

Example: Stack and Heap Memory

class MemoryExample {
    int instanceVariable; // Stored in Heap

    void method() {
        int localVariable = 10; // Stored in Stack
        MemoryExample obj = new MemoryExample(); // obj reference is in Stack, object is in Heap
    }
}

Garbage Collection Basics

Garbage collection (GC) in Java automatically frees up memory by removing unused objects from the heap. It prevents memory leaks and enhances application performance.

How Garbage Collection Works

• Mark and Sweep: Identifies unused objects and clears them from memory.

• Generational Garbage Collection: Java divides heap memory into Young Generation, Old Generation, and Permanent Generation for efficient management.

Example: Forcing Garbage Collection (Not Recommended for Production)

public class GCDemo {
    public static void main(String[] args) {
        GCDemo obj = new GCDemo();
        obj = null; // Object is now eligible for garbage collection
        System.gc(); // Suggests JVM to run Garbage Collector
        System.out.println("Garbage Collection requested");
    }
}

Best Practices to Avoid Memory Leaks in Java

1. Release References When No Longer Needed

   Set object references to null if they won’t be used again — especially in long-lived collections or caches.

2. Avoid Unbounded Object Retention

   Be cautious when adding objects to collections like List, Map, or Set. If you forget to remove them, the JVM won’t garbage collect them.

3. Be Careful with Static Fields

   Static variables live for the lifetime of the application. If they hold references to large objects or collections, those won't be garbage collected.

4. Monitor with Tools

   Use profiling tools like VisualVM, JConsole, or Eclipse MAT to monitor memory usage and detect leaks during testing.

5. Close Resources Properly

   Use try-with-resources for streams, JDBC, etc.

    try (FileInputStream fis = new FileInputStream("data.txt")) {
        // Auto-closed
    }
   

The Java Memory Model (JMM)

The Java Memory Model defines how threads interact through memory which is crucial for concurrency and thread safety.

• It specifies rules about visibility and ordering of variables across threads.

• Without it, changes made by one thread may not be seen by another due to CPU caching or compiler optimizations.

Key Concepts

• Happens-Before Relationship
  Ensures that memory writes by one thread are visible to another under certain conditions (e.g., synchronized, volatile, thread start()/join()).

• Volatile Variables
  Ensure visibility, that is changes made by one thread are always seen by others.

Memory Areas in the JVM

Conclusion

Understanding Java memory management is essential for writing efficient and optimized applications. By knowing how stack and heap memory work and how garbage collection operates, developers can avoid memory leaks and improve performance.

Stay tuned for the next topic in the Java Short Notes series!