Memory Management & Garbage Collection

public class Main {
    // A small class so we can watch objects being born and abandoned.
    static class User {
        String name;                 // a reference field, lives inside the object on the heap
        User(String name) {
            this.name = name;
            System.out.println("Created on heap: " + name);
        }
    }

    public static void main(String[] args) {
        // 'count' is a primitive — its VALUE lives on the stack frame for main().
        int count = 2;
        System.out.println("count (stack primitive) = " + count);

        // 'alice' is a reference on the stack pointing at a User OBJECT on the heap.
        User alice = new User("Alice");
        User bob   = new User("Bob");

        // Copy the REFERENCE, not the object. alias and alice point at the SAME object.
        User alias = alice;
        System.out.println("alias == alice ? " + (alias == alice));   // true: same object

        // Dropping one reference does NOT free the object — alias still holds it.
        alice = null;
        System.out.println("alice = null, but alias keeps Alice alive");

        // Now no reference points at Alice -> she is eligible for garbage collection.
        alias = null;
        bob   = null;
        System.out.println("alias/bob = null -> both objects now eligible for GC");

        // GC runs automatically; you never call free()/delete() in Java.
        System.gc();   // a HINT, not a command — the JVM decides when to actually collect
        System.out.println("Asked the JVM to consider a GC cycle");
    }
}

count (stack primitive) = 2
Created on heap: Alice
Created on heap: Bob
alias == alice ? true
alice = null, but alias keeps Alice alive
alias/bob = null -> both objects now eligible for GC
Asked the JVM to consider a GC cycle

// Run your program with GC logging turned on to SEE collections happen:
//   java -Xlog:gc -Xmx64m Main
//
// This program allocates lots of short-lived "garbage" so the young
// generation fills up and minor GCs fire. Most objects die young, which
// is exactly the assumption generational GC is built around.

public class Main {
    public static void main(String[] args) {
        long kept = 0;
        for (int i = 0; i < 5_000_000; i++) {
            byte[] block = new byte[256];   // born in Eden (young generation)
            kept += block.length;           // touch it so the JIT can't delete it
            // 'block' goes out of scope each loop -> instantly becomes garbage
        }
        System.out.println("Allocated and discarded ~" + (kept / 1024 / 1024) + " MB of garbage");
    }
}

[0.012s][info][gc] Using G1
[0.103s][info][gc] GC(0) Pause Young (Normal) (G1 Evacuation Pause) 24M->2M(64M) 1.842ms
[0.198s][info][gc] GC(1) Pause Young (Normal) (G1 Evacuation Pause) 26M->2M(64M) 1.611ms
[0.291s][info][gc] GC(2) Pause Young (Normal) (G1 Evacuation Pause) 26M->2M(64M) 1.503ms
Allocated and discarded ~1220 MB of garbage

import java.lang.ref.WeakReference;
import java.util.WeakHashMap;
import java.util.Map;

public class Main {
    static class Image {            // pretend this is a big, expensive object
        final String name;
        Image(String name) { this.name = name; }
    }

    public static void main(String[] args) {
        // STRONG reference: the normal kind. Never collected while reachable.
        Image logo = new Image("logo.png");
        System.out.println("Strong ref holds: " + logo.name);

        // WEAK reference: lets the GC reclaim the object as soon as no STRONG ref remains.
        Image banner = new Image("banner.png");
        WeakReference<Image> weak = new WeakReference<>(banner);
        System.out.println("Weak ref before: " + (weak.get() != null ? weak.get().name : "collected"));
        banner = null;     // drop the only strong reference to the banner
        System.gc();       // hint the GC to run
        System.out.println("Weak ref after GC: " + (weak.get() != null ? weak.get().name : "collected"));

        // WeakHashMap: entries disappear automatically when their KEY is no longer
        // strongly reachable. Perfect for caches that must not cause leaks.
        Map<Object, String> cache = new WeakHashMap<>();
        Object key = new Object();
        cache.put(key, "expensive result");
        System.out.println("Cache size while key is held: " + cache.size());
        key = null;        // the only strong ref to the key is gone
        System.gc();
        System.out.println("WeakHashMap auto-evicts entries whose key was collected");
    }
}

Strong ref holds: logo.png
Weak ref before: banner.png
Weak ref after GC: collected
Cache size while key is held: 1
WeakHashMap auto-evicts entries whose key was collected

public class Main {
    static class Session {
        final String id;
        Session(String id) {
            this.id = id;
            System.out.println("Opened session " + id);
        }
    }

    public static void main(String[] args) {
        // 🎯 YOUR TURN — fill in the blanks marked with ___

        // 1) Create a Session with id "A" using 'new'
        Session a = ___;                 // 👉 new Session("A")

        // 2) Make 'copy' point at the SAME object as 'a' (copy the reference)
        Session copy = ___;              // 👉 just write: a

        // 3) Drop ONE reference. The object is NOT collected yet — 'copy' still holds it.
        a = null;
        System.out.println("a = null, object still alive via copy");

        // 4) Make the object eligible for GC by dropping the LAST reference
        copy = ___;                      // 👉 set it to null

        System.out.println("Session is now eligible for garbage collection");

        // ✅ Expected output:
        // Opened session A
        // a = null, object still alive via copy
        // Session is now eligible for garbage collection
    }
}

import java.util.ArrayList;
import java.util.List;

public class Main {
    // ⚠️ A 'static' field lives for the whole program. If it only ever GROWS,
    // every object you add stays reachable forever — a classic Java memory leak.
    static List<byte[]> LEAK = new ArrayList<>();

    static void cacheBadly() {
        // 🎯 YOUR TURN — fill in the blanks marked with ___

        // 1) Add a 1 KB block to the static list (this is the leak — nothing removes it)
        LEAK.add(___);                   // 👉 new byte[1024]
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            cacheBadly();
        }

        // 2) Print how many blocks are still being held alive by the static list
        System.out.println("Blocks the static list is keeping alive: " + LEAK.___());   // 👉 size

        // ✅ Expected output:
        // Blocks the static list is keeping alive: 3
        // Fix: remove entries, use a bounded cache, or hold WeakReferences.
        System.out.println("Fix: remove entries, use a bounded cache, or hold WeakReferences.");
    }
}

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // 🎯 MINI-CHALLENGE: a self-cleaning cache
        // 1. Create a Map<Object, String> that auto-evicts entries when the KEY
        //    is no longer strongly reachable  (hint: WeakHashMap)
        // 2. Put one entry in using a key you hold in a variable, then print size()  (expect 1)
        // 3. Set that key variable to null, call System.gc(), then print size() again
        // 4. Explain in a println WHY the size can now drop to 0
        //
        // ✅ Expected (GC permitting):
        // Size with key held: 1
        // Size after key dropped: 0
        // The entry left because its key had no strong references.

        // your code here
    }
}

# JVM memory tuning is done with LAUNCH FLAGS, not Java code.

# Typical production launch: fixed heap + G1 collector + heap dump on OOM
java -Xms512m -Xmx2g \
     -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=200 \
     -XX:+HeapDumpOnOutOfMemoryError \
     -jar my-app.jar

# What the key flags mean:
#   -Xms512m                 initial heap size (set = -Xmx in prod to avoid resize pauses)
#   -Xmx2g                   MAX heap size  (keep <= ~75% of the box's RAM)
#   -XX:+UseG1GC             G1 collector (default since Java 9); -XX:+UseZGC for low latency
#   -XX:MaxGCPauseMillis=200 target pause time for G1, in milliseconds
#   -Xss512k                 per-thread stack size (lower it when running many threads)

# See GC happen, then inspect a running JVM (get <pid> from 'jps'):
java -Xlog:gc*:file=gc.log:time -jar my-app.jar   # write a full GC log
jcmd <pid> GC.heap_info                            # current heap usage
jmap -histo <pid>                                  # histogram of live objects (leak hunting)