🗑️ Java Garbage Collector

public class GC_NullAssign1 {

    String name;
    int    id;

    GC_NullAssign1(int id, String name) {
        this.id   = id;
        this.name = name;
        System.out.println("CREATED  → Object #" + id
            + " (" + name + ")");
    }

    // JVM calls this BEFORE destroying object
    protected void finalize() {
        System.out.println("DESTROYED → Object #" + id
            + " (" + name + ") collected by GC!");
    }

    public static void main(String[] args) {

        System.out.println("=== Case 1: null assign ===\n");

        // Object create karo
        GC_NullAssign1 obj1 = new GC_NullAssign1(1, "Alpha");
        GC_NullAssign1 obj2 = new GC_NullAssign1(2, "Beta");
        GC_NullAssign1 obj3 = new GC_NullAssign1(3, "Gamma");

        System.out.println("\n--- Using objects ---");
        System.out.println("obj1: " + obj1.name);
        System.out.println("obj2: " + obj2.name);
        System.out.println("obj3: " + obj3.name);

        System.out.println("\n--- null assign → GC eligible ---");
        obj1 = null;  // Object #1 orphan!
        obj2 = null;  // Object #2 orphan!
        // obj3 abhi bhi referenced → safe

        System.out.println("obj1 = null (Object #1 eligible for GC)");
        System.out.println("obj2 = null (Object #2 eligible for GC)");
        System.out.println("obj3 still referenced → SAFE");

        System.out.println("\n--- Requesting GC ---");
        System.gc(); // Request (guarantee nahi!)
        // GC ko thoda time do
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("\n--- After GC ---");
        System.out.println("obj3 still alive: " + obj3.name);
    }
}

public class GC_NullAssign2 {

    static int destroyCount = 0;
    int id;

    GC_NullAssign2(int id) {
        this.id = id;
    }

    protected void finalize() {
        destroyCount++;
        System.out.println("  GC destroyed Object #" + id
            + " | Total destroyed: " + destroyCount);
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("=== Bulk null assign ===\n");

        int SIZE = 10;
        GC_NullAssign2[] objects = new GC_NullAssign2[SIZE];

        // Create all objects
        System.out.println("Creating " + SIZE + " objects...");
        for (int i = 0; i < SIZE; i++) {
            objects[i] = new GC_NullAssign2(i + 1);
        }
        System.out.println("All " + SIZE + " objects created!\n");

        // Null assign selectively
        System.out.println("Making even-indexed objects eligible...");
        for (int i = 0; i < SIZE; i++) {
            if (i % 2 == 0) {
                objects[i] = null; // even index → null
            }
        }

        System.out.println("Requesting GC...");
        System.gc();
        Thread.sleep(1000);

        System.out.println("\nSurviving objects (odd index):");
        for (int i = 0; i < SIZE; i++) {
            if (objects[i] != null) {
                System.out.println("  Object #" + objects[i].id
                    + " → alive");
            }
        }
        System.out.println("\nTotal destroyed: " + destroyCount);
    }
}

public class GC_NullAssign3 {

    // null assign - memory before/after visualization
    String data;
    int    size;

    GC_NullAssign3(String data) {
        this.data = data;
        this.size = data.length() * 2; // bytes (approx)
        System.out.println("  ALLOCATED: '" + data
            + "' (~" + size + " bytes)");
    }

    protected void finalize() {
        System.out.println("  FREED:     '" + data
            + "' (~" + size + " bytes)");
    }

    static void showMemory(String label) {
        Runtime rt = Runtime.getRuntime();
        long total = rt.totalMemory();
        long free  = rt.freeMemory();
        long used  = total - free;
        System.out.printf("[%s] Used: %d KB | Free: %d KB%n",
            label,
            used  / 1024,
            free  / 1024);
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("=== Memory Tracking ===\n");
        showMemory("Start");

        System.out.println("\nCreating objects...");
        GC_NullAssign3 o1 = new GC_NullAssign3("Hello World");
        GC_NullAssign3 o2 = new GC_NullAssign3("Java GC Demo");
        GC_NullAssign3 o3 = new GC_NullAssign3("Memory Management");
        showMemory("After Create");

        System.out.println("\nAssigning null...");
        o1 = null;
        o2 = null;
        o3 = null;
        showMemory("After Null");

        System.out.println("\nRunning GC...");
        System.gc();
        Thread.sleep(500);
        showMemory("After GC");
    }
}

public class GC_NullAssign4 {

    // Chain of references - null assign kab eligible
    int id;
    GC_NullAssign4 next; // reference to another object

    GC_NullAssign4(int id) {
        this.id = id;
    }

    protected void finalize() {
        System.out.println("  Destroyed: Object #" + id);
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("=== Reference Chain Demo ===\n");

        // Chain: a → b → c
        GC_NullAssign4 a = new GC_NullAssign4(1);
        GC_NullAssign4 b = new GC_NullAssign4(2);
        GC_NullAssign4 c = new GC_NullAssign4(3);

        a.next = b; // a → b
        b.next = c; // b → c

        System.out.println("Chain: a(#1) → b(#2) → c(#3)");
        System.out.println("a references: #" + a.id);
        System.out.println("b references: #" + b.id);
        System.out.println("c references: #" + c.id);

        // b aur c reference remove karo (but a.next still points to b!)
        System.out.println("\nb = null, c = null");
        b = null;
        c = null;

        System.out.println("GC request...");
        System.gc();
        Thread.sleep(500);
        // b aur c ke objects destroy nahi hue!
        // kyunki a.next → b, b.next → c (chain se reachable!)

        System.out.println("a.next still alive: #"
            + a.next.id);   // b still accessible via a!
        System.out.println("a.next.next alive:  #"
            + a.next.next.id); // c still accessible via chain!

        System.out.println("\nNow a = null → whole chain orphan!");
        a = null; // ab koi bhi chain tak nahi pahunch sakta!
        System.gc();
        Thread.sleep(500);
        System.out.println("Chain completely destroyed!");
    }
}

public class GC_MethodScope1 {

    String name;
    int    id;
    static int counter = 0;

    GC_MethodScope1(String name) {
        counter++;
        this.id   = counter;
        this.name = name;
        System.out.println("  BORN:  #" + id + " '" + name + "'");
    }

    protected void finalize() {
        System.out.println("  DIED:  #" + id + " '" + name + "'");
    }

    // Method mein object create karo
    static void temporaryWork() {
        System.out.println("  → Method started");

        // Local objects - method scope mein
        GC_MethodScope1 temp1 = new GC_MethodScope1("TempA");
        GC_MethodScope1 temp2 = new GC_MethodScope1("TempB");

        System.out.println("  → Using: "
            + temp1.name + ", " + temp2.name);
        System.out.println("  → Method ending...");
        // Method ends → temp1, temp2 destroyed!
        // Objects TempA, TempB → GC eligible!
    }

    static void persistentWork() {
        System.out.println("  → Persistent method");
        GC_MethodScope1 p = new GC_MethodScope1("Persistent");
        System.out.println("  → Using: " + p.name);
        // p bhi method ke end pe eligible hoga
        // lekin hum ise return kar rahe hain
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("=== Case 2: Method Scope ===\n");

        System.out.println("--- Calling temporaryWork() ---");
        temporaryWork();

        System.out.println("\n--- Requesting GC ---");
        System.gc();
        Thread.sleep(500);

        System.out.println("\n--- Calling again ---");
        temporaryWork();
        System.gc();
        Thread.sleep(500);

        System.out.println("\nMain ends.");
    }
}

public class GC_MethodScope2 {

    String type;
    double value;

    GC_MethodScope2(String type, double value) {
        this.type  = type;
        this.value = value;
        System.out.println("  Created: " + type);
    }

    protected void finalize() {
        System.out.println("  Collected: " + type);
    }

    // Method that returns object - NOT eligible!
    static GC_MethodScope2 createAndReturn() {
        GC_MethodScope2 obj =
            new GC_MethodScope2("Returned", 100.0);
        System.out.println("  Returning object...");
        return obj; // caller holds reference → NOT eligible!
    }

    // Method that does NOT return - eligible!
    static void createAndDiscard() {
        GC_MethodScope2 obj =
            new GC_MethodScope2("Discarded", 200.0);
        System.out.println("  Using: " + obj.value);
        // method ends, obj not returned → eligible!
    }

    // Conditional - sometimes eligible
    static GC_MethodScope2 conditionalReturn(boolean returnIt) {
        GC_MethodScope2 obj =
            new GC_MethodScope2("Conditional", 300.0);
        if (returnIt) {
            return obj; // NOT eligible
        }
        return null; // obj eligible!
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("=== Return vs Discard ===\n");

        System.out.println("1. createAndReturn():");
        GC_MethodScope2 kept = createAndReturn();
        System.gc();
        Thread.sleep(300);
        System.out.println("kept still alive: " + kept.type);

        System.out.println("\n2. createAndDiscard():");
        createAndDiscard();
        System.gc();
        Thread.sleep(300);

        System.out.println("\n3. conditionalReturn(true):");
        GC_MethodScope2 r = conditionalReturn(true);
        System.gc();
        Thread.sleep(300);
        System.out.println("r alive: " + r.type);

        System.out.println("\n4. conditionalReturn(false):");
        conditionalReturn(false);
        System.gc();
        Thread.sleep(300);
    }
}

public class GC_MethodScope3 {

    String label;
    static int gcCount = 0;

    GC_MethodScope3(String label) {
        this.label = label;
    }

    protected void finalize() {
        gcCount++;
        System.out.println("  GC #" + gcCount + ": " + label);
    }

    // Nested method calls - GC kab hoga?
    static void outerMethod() {
        GC_MethodScope3 outer =
            new GC_MethodScope3("Outer");
        System.out.println("  Outer created");

        innerMethod(); // inner call karo

        System.out.println("  Back in outer: "
            + outer.label + " still alive");
        // outer method khatam pe eligible
    }

    static void innerMethod() {
        GC_MethodScope3 inner =
            new GC_MethodScope3("Inner");
        System.out.println("  Inner created, doing work...");
        // inner method khatam → inner eligible
    }

    // Loop mein objects
    static void loopObjects() {
        System.out.println("\n  Loop creating objects:");
        for (int i = 1; i <= 5; i++) {
            GC_MethodScope3 loopObj =
                new GC_MethodScope3("Loop#" + i);
            System.out.println("  Using: " + loopObj.label);
            // Iteration end pe loopObj eligible!
            // Agle iteration mein naya object!
        }
        System.out.println("  Loop done!");
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("=== Nested Method Scope ===\n");

        outerMethod();
        System.gc();
        Thread.sleep(300);

        System.out.println("\nGC count after outerMethod: "
            + gcCount);

        loopObjects();
        System.gc();
        Thread.sleep(300);

        System.out.println("GC count after loop: "
            + gcCount);
    }
}

public class GC_MethodScope4 {

    String name;
    int[] bigArray; // large memory

    GC_MethodScope4(String name, int size) {
        this.name     = name;
        this.bigArray = new int[size]; // allocate memory
        // Fill array
        for (int i = 0; i < size; i++) bigArray[i] = i;
        System.out.printf("  Allocated: %-15s (%d ints = ~%d KB)%n",
            name, size, size * 4 / 1024);
    }

    protected void finalize() {
        System.out.printf("  Freed:     %-15s (%d ints)%n",
            name, bigArray.length);
    }

    static long usedMemory() {
        Runtime rt = Runtime.getRuntime();
        return (rt.totalMemory() - rt.freeMemory()) / 1024;
    }

    static void processData(String label, int size) {
        // Local large object
        GC_MethodScope4 data =
            new GC_MethodScope4(label, size);
        // Process...
        long sum = 0;
        for (int v : data.bigArray) sum += v;
        System.out.println("  Sum: " + sum);
        // Method ends → data eligible for GC!
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("=== Large Object Method Scope ===\n");
        System.out.println("Initial memory: " + usedMemory() + " KB");

        System.out.println("\nProcessing datasets:");
        processData("Dataset-A", 50000);  // ~200 KB
        processData("Dataset-B", 100000); // ~400 KB
        processData("Dataset-C", 75000);  // ~300 KB

        System.out.println("\nBefore GC: " + usedMemory() + " KB");
        System.gc();
        Thread.sleep(500);
        System.out.println("After GC:  " + usedMemory() + " KB");
        System.out.println("\nMemory recovered!");
    }
}

public class GC_Reassign1 {

    String name;
    int    version;

    GC_Reassign1(String name, int version) {
        this.name    = name;
        this.version = version;
        System.out.println("  CREATED: " + name + " v" + version);
    }

    protected void finalize() {
        System.out.println("  GC DONE: " + name + " v" + version);
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("=== Case 3: Reference Reassign ===\n");

        // 2 references, 2 objects
        GC_Reassign1 ref1 =
            new GC_Reassign1("Config", 1);
        GC_Reassign1 ref2 =
            new GC_Reassign1("Config", 2);

        System.out.println("\nref1 → " + ref1.name
            + " v" + ref1.version);
        System.out.println("ref2 → " + ref2.name
            + " v" + ref2.version);

        // Reassign - purana orphan!
        System.out.println("\n--- ref1 = ref2 ---");
        ref1 = ref2; // ref1 ab v2 ko point karta hai
                     // v1 object → ORPHAN!

        System.out.println("ref1 now → " + ref1.name
            + " v" + ref1.version);
        System.out.println("ref2 → " + ref2.name
            + " v" + ref2.version);
        System.out.println("Config v1 → ORPHAN!");

        System.gc();
        Thread.sleep(500);

        System.out.println("\nBoth ref1 & ref2 point to: "
            + ref1.name + " v" + ref1.version);
        System.out.println("Are same? " + (ref1 == ref2)); // true!
    }
}

public class GC_Reassign2 {

    String generation;
    static int gcCount = 0;

    GC_Reassign2(String gen) {
        this.generation = gen;
        System.out.println("  Born: Generation " + gen);
    }

    protected void finalize() {
        gcCount++;
        System.out.println("  Died: Generation " + generation
            + " | Total GC: " + gcCount);
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("=== Reassign Chain Demo ===\n");

        // Single reference, multiple reassignments
        GC_Reassign2 product =
            new GC_Reassign2("1.0");

        System.out.println("\nUpgrade to 2.0:");
        product = new GC_Reassign2("2.0"); // 1.0 orphan!
        System.gc(); Thread.sleep(300);

        System.out.println("\nUpgrade to 3.0:");
        product = new GC_Reassign2("3.0"); // 2.0 orphan!
        System.gc(); Thread.sleep(300);

        System.out.println("\nUpgrade to 4.0:");
        product = new GC_Reassign2("4.0"); // 3.0 orphan!
        System.gc(); Thread.sleep(300);

        System.out.println("\nCurrent: Generation "
            + product.generation);
        System.out.println("Total collected: " + gcCount);
    }
}

public class GC_Reassign3 {

    // All 3 cases together!
    String label;
    static int born = 0, died = 0;

    GC_Reassign3(String label) {
        born++;
        this.label = label;
    }

    protected void finalize() {
        died++;
        System.out.println("  GC: " + label);
    }

    // Case 2 helper
    static void methodScope() {
        GC_Reassign3 m = new GC_Reassign3("MethodLocal");
        System.out.println("  Inside method: " + m.label);
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("=== All 3 GC Cases ===\n");

        // CASE 1: null assign
        System.out.println("CASE 1: null assign");
        GC_Reassign3 c1 = new GC_Reassign3("NullCase");
        c1 = null; // orphan!
        System.gc(); Thread.sleep(300);

        // CASE 2: Method scope
        System.out.println("\nCASE 2: Method scope");
        methodScope();
        System.gc(); Thread.sleep(300);

        // CASE 3: Reassign
        System.out.println("\nCASE 3: Reassign");
        GC_Reassign3 r = new GC_Reassign3("Old");
        r = new GC_Reassign3("New"); // Old orphan!
        System.gc(); Thread.sleep(300);
        System.out.println("  Current: " + r.label);

        System.out.println("\n=== Summary ===");
        System.out.println("Total created: " + born);
        System.out.println("Total collected: " + died);
    }
}

public class Finalize1 {

    String resourceName;
    boolean isOpen;
    static int finalizeCount = 0;

    Finalize1(String resourceName) {
        this.resourceName = resourceName;
        this.isOpen       = true;
        System.out.println("  Resource OPENED: " + resourceName);
    }

    void close() {
        if (isOpen) {
            isOpen = false;
            System.out.println("  Resource CLOSED manually: "
                + resourceName);
        }
    }

    // JVM calls before destroying
    protected void finalize() {
        finalizeCount++;
        if (isOpen) {
            System.out.println("  finalize() #" + finalizeCount
                + ": Auto-closing " + resourceName
                + " (was not closed manually!)");
            isOpen = false;
        } else {
            System.out.println("  finalize() #" + finalizeCount
                + ": " + resourceName + " already closed");
        }
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("=== finalize() Demo ===\n");

        // Case 1: Manually closed then GC
        System.out.println("--- Case 1: Manual close ---");
        Finalize1 res1 = new Finalize1("DatabaseConnection");
        res1.close();    // manually close kiya
        res1 = null;
        System.gc();
        Thread.sleep(300);

        // Case 2: NOT closed - finalize auto-closes
        System.out.println("\n--- Case 2: Forgot to close ---");
        Finalize1 res2 = new Finalize1("FileHandler");
        // close() call nahi kiya! (developer bhool gaya)
        res2 = null;
        System.gc();
        Thread.sleep(300);

        // Case 3: Method scope
        System.out.println("\n--- Case 3: Method scope ---");
        {
            Finalize1 res3 =
                new Finalize1("NetworkSocket");
            System.out.println("  Using resource...");
            // close nahi kiya
        } // scope ends → eligible
        System.gc();
        Thread.sleep(300);

        System.out.println("\nTotal finalize() calls: "
            + finalizeCount);
    }
}

public class Finalize2 {

    // finalize() with exception - GC ignore karta hai!
    String name;
    boolean throwException;

    Finalize2(String name, boolean throwException) {
        this.name           = name;
        this.throwException = throwException;
        System.out.println("  Created: " + name);
    }

    protected void finalize() {
        System.out.println("  finalize() called: " + name);

        if (throwException) {
            System.out.println("  THROWING exception in finalize()!");
            throw new RuntimeException(
                "Error in finalize of " + name);
            // Exception aaye to:
            // 1. GC exception IGNORE karta hai
            // 2. Object PHIR BHI destroy hota hai!
        }

        System.out.println("  finalize() completed: " + name);
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("=== finalize() Exception Demo ===\n");

        // Normal finalize
        System.out.println("--- Normal finalize ---");
        Finalize2 normal =
            new Finalize2("Normal", false);
        normal = null;
        System.gc();
        Thread.sleep(500);

        // finalize with exception
        System.out.println("\n--- Exception in finalize ---");
        Finalize2 exceptional =
            new Finalize2("Exceptional", true);
        exceptional = null;
        System.gc();
        Thread.sleep(500);

        System.out.println("\nProgram continues normally!");
        System.out.println("Exception in finalize did NOT crash program");
        System.out.println("GC ignored exception and destroyed object");
    }
}

public class Finalize3 {

    // System.gc() vs Runtime.getRuntime().gc()
    String id;
    static int count = 0;

    Finalize3(String id) {
        this.id = id;
        System.out.println("  Born: " + id);
    }

    protected void finalize() {
        count++;
        System.out.println("  Dead: " + id
            + " | count=" + count);
    }

    static void createObjects(String prefix, int n) {
        for (int i = 1; i <= n; i++) {
            Finalize3 obj = new Finalize3(prefix + i);
        }
        // All objects eligible after loop!
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("=== System.gc() Methods ===\n");

        System.out.println("--- Creating 5 objects ---");
        createObjects("Obj", 5);
        System.out.println("All 5 eligible for GC\n");

        // Method 1: System.gc()
        System.out.println("Method 1: System.gc()");
        System.gc(); // Request GC
        Thread.sleep(500);
        System.out.println("After System.gc(): count = " + count);

        System.out.println("\n--- Creating 5 more ---");
        createObjects("NewObj", 5);
        count = 0; // reset

        // Method 2: Runtime.getRuntime().gc()
        System.out.println("\nMethod 2: Runtime.getRuntime().gc()");
        Runtime.getRuntime().gc(); // Same as System.gc()
        Thread.sleep(500);
        System.out.println("After Runtime.gc(): count = " + count);

        System.out.println("\n=== Both are equivalent! ===");
        System.out.println("System.gc() internally calls");
        System.out.println("Runtime.getRuntime().gc()");
    }
}

public class Finalize4 {

    // Complete GC summary program
    // All cases + finalize + gc methods
    String name;
    String caseType;
    static int totalCreated  = 0;
    static int totalDestroyed = 0;

    Finalize4(String name, String caseType) {
        totalCreated++;
        this.name     = name;
        this.caseType = caseType;
        System.out.printf("  [+] %-20s (Case: %s)%n",
            name, caseType);
    }

    protected void finalize() {
        totalDestroyed++;
        System.out.printf("  [-] %-20s → GC collected%n", name);
    }

    // Case 2 helper
    static void methodScopeCase() {
        new Finalize4("MethodObj1", "Method");
        new Finalize4("MethodObj2", "Method");
    }

    public static void main(String[] args)
            throws InterruptedException {

        System.out.println("╔══════════════════════════════╗");
        System.out.println("║  GC COMPLETE DEMO            ║");
        System.out.println("╚══════════════════════════════╝\n");

        // === CASE 1: null assign ===
        System.out.println("【CASE 1】 null assign:");
        Finalize4 c1 = new Finalize4("NullObj1", "Null");
        Finalize4 c2 = new Finalize4("NullObj2", "Null");
        c1 = null;  // orphan!
        c2 = null;  // orphan!

        // === CASE 2: Method scope ===
        System.out.println("\n【CASE 2】 Method scope:");
        methodScopeCase(); // objects created and discarded

        // === CASE 3: Reassign ===
        System.out.println("\n【CASE 3】 Reference reassign:");
        Finalize4 r = new Finalize4("ReassignOld", "Reassign");
        r = new Finalize4("ReassignNew", "Reassign"); // old orphan!

        // === GC Request ===
        System.out.println("\n【GC REQUEST】 System.gc():");
        System.gc();
        Thread.sleep(1000);

        System.out.println("\n【SUMMARY】");
        System.out.println("  Total Created:   " + totalCreated);
        System.out.println("  Total Destroyed: " + totalDestroyed);
        System.out.println("  Still alive: "
            + (totalCreated - totalDestroyed));
        System.out.println("  Alive object: " + r.name);
    }
}