feat(GCDemo1): add demo of WeakReference, strong refs, and GC with ReferenceQueue

What
- Added `GCDemo1` class with nested `Big` class (allocates ~1MB array).
- Created:
  • Strong reference → Big#1
  • WeakReference (weak1) → Big#2 (no strong refs)
  • WeakReference (weak2) → Big#1 (also held by strong initially)
- Used `ReferenceQueue<Big>` to capture cleared weak references.
- Printed object states before and after `System.gc()` and checked queue.

Why
- To demonstrate how JVM garbage collector handles strong vs weak references.
- Showed how weak references are cleared when no strong refs exist.
- Illustrated how ReferenceQueue helps detect when referents are reclaimed.
- Useful for cache design and avoiding memory leaks.

How
- Before GC:
  strong → Big#1
  weak1.get() → Big#2
  weak2.get() → Big#1
  refQueue empty
- After nulling strong and running GC:
  weak1.get() → null (Big#2 reclaimed)
  weak2.get() → null (Big#1 reclaimed)
  refQueue contains [weak1, weak2]
- Printed enqueued weak refs from refQueue.

Logic
- Inputs:
  - Instantiated Big objects with ids 1 and 2.
- Outputs:
  - Console logs showing object states before/after GC.
  - Enqueued references from ReferenceQueue.
- Flow:
  1. Create strong + weak refs.
  2. Print pre-GC states.
  3. strong = null.
  4. Call System.gc() and sleep briefly.
  5. Print post-GC states.
  6. Drain ReferenceQueue to show cleared refs.
- Constraints:
  - GC behavior not strictly guaranteed; System.gc() is only a hint.
- Complexity:
  - O(1) reference checks, O(n) to drain queue (n = cleared refs).

Real-life applications
- WeakReference used in caches where objects can be reclaimed automatically.
- Helps avoid memory leaks when object lifetime should not be strictly managed.
- ReferenceQueue allows cleanup tasks when objects are collected.

Notes
- Strong refs keep objects alive.
- Weak refs do not prevent GC.
- ReferenceQueue signals GC-cleared refs.
- Demo shows memory pressure handling and lifecycle of weak references.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Garbage Collection/src/GCDemo1.java

@@ -0,0 +1,139 @@
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class GCDemo1 {
+    // A simple object with a moderately large byte[] so GC will likely reclaim it under pressure.
+    static class Big {
+        private final byte[] data;
+        private final int id;
+
+        Big(int id) {
+            this.id = id;
+            // allocate ~1MB so GC can notice memory pressure in small demos
+            this.data = new byte[1_000_000];
+        }
+
+        @Override
+        public String toString() {
+            return "Big#" + id;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        ReferenceQueue<Big> refQueue = new ReferenceQueue<>();
+
+        // 1) Strong reference: will keep object alive until cleared
+        Big strong = new Big(1);
+
+        // 2) WeakReference to a freshly created Big(2) — no strong ref -> eligible immediately
+        WeakReference<Big> weak1 = new WeakReference<>(new Big(2), refQueue);
+
+        // 3) WeakReference to the object currently held by "strong"
+        WeakReference<Big> weak2 = new WeakReference<>(strong, refQueue);
+
+        System.out.println("Before GC:");
+        System.out.println("  strong = " + strong);
+        System.out.println("  weak1.get() = " + weak1.get());
+        System.out.println("  weak2.get() = " + weak2.get());
+        System.out.println("  refQueue.poll() = " + refQueue.poll());
+        System.out.println();
+
+        // Make the previously-strong object eligible for GC by removing the strong ref
+        strong = null;
+
+        // Suggest GC and wait a bit — JVM may run GC and clear weak refs
+        System.gc();
+        Thread.sleep(800);
+
+        System.out.println("After GC:");
+        System.out.println("  weak1.get() = " + weak1.get()); // most likely null (no strong refs ever)
+        System.out.println("  weak2.get() = " + weak2.get()); // likely null now (strong was nulled)
+        System.out.println();
+
+        // Inspect reference queue to see which weak references were enqueued after GC
+        Reference<? extends Big> enqueued;
+        while ((enqueued = refQueue.poll()) != null) {
+            System.out.println("Reference enqueued (cleared by GC): " + enqueued);
+        }
+
+        System.out.println("\nDemo finished.");
+    }
+}
+
+/*
+1. Purpose of Code:
+- Yeh program dikhata hai ki JVM Garbage Collector **strong** aur **weak** references ko kaise treat karta hai.
+- `WeakReference` wali objects strong reference ke bina garbage collect ho sakti hain.
+- Agar object GC ke dwara clear hoti hai, toh weak reference ko `ReferenceQueue` me daal diya jata hai.
+
+2. Important Parts:
+- Big class: ek heavy object (~1MB array) banaya gaya hai taaki GC ko pressure dikhe.
+- strong reference: object ko alive rakhta hai jab tak null nahi hota.
+- weak1: ek object ke liye jo sirf weakly referenced hai, aur jaldi collect ho jaayega.
+- weak2: initially same object ko point karta hai jo strong bhi refer kar raha hai.
+- ReferenceQueue: jab weak reference clear hota hai, JVM usko queue me enqueue kar deta hai.
+
+3. Execution Flow:
+
+- Before GC:
+       strong -> Big#1
+       weak1.get() -> Big#2
+       weak2.get() -> Big#1
+       refQueue = empty
+
+- After `strong = null;` + GC:
+       strong -> null
+       weak1.get() -> null (collected)
+       weak2.get() -> null (collected)
+       refQueue -> [weak1, weak2]
+
+4. ASCII Diagram:
+
+   Before GC:
+   -------------------------
+   strong ---> [Big#1]
+   weak1 -X-> [Big#2]
+   weak2 -X-> [Big#1]
+   refQueue: empty
+   -------------------------
+
+   After GC:
+   -------------------------
+   strong -> null
+   weak1.get() -> null
+   weak2.get() -> null
+   refQueue: [weak1, weak2]
+   -------------------------
+
+5. Quick Recap:
+✔ Strong reference: object ko GC se bachata hai.
+✔ Weak reference: GC kabhi bhi clear kar sakta hai agar strong ref na ho.
+✔ ReferenceQueue: pata lagta hai ki object collect ho gaya.
+✔ `System.gc()` sirf JVM ko suggestion deta hai (force nahi).
+
+Practical Use:
+- Weak references caches me use hote hain.
+- Yeh memory leaks prevent karte hain jab object ki lifetime app ke control me nahi hoti.
+
+Initially (before pulling strong):
+Heap:
+[ Big#1 ] <-- strong
+[ Big#2 ] <-- only weak1 (no strong)
+References:
+strong -> Big#1
+weak1 -X-> Big#2 (weak)
+weak2 -X-> Big#1 (weak)
+refQueue: empty
+
+
+After strong = null and GC:
+Heap:
+[ <free> ]  (Big#1 reclaimed)
+[ <free> ]  (Big#2 reclaimed)
+References:
+strong -> null
+weak1.get() -> null
+weak2.get() -> null
+refQueue: [ weak1, weak2 ]  (weak refs enqueued)
+*/