feat(PhantomDemo): add demo of PhantomReference with ReferenceQueue cleanup

What
- Implemented `PhantomDemo` to illustrate PhantomReference usage.
- Created `NativeResource` object with strong ref, then wrapped in PhantomReference.
- Demonstrated that `pr.get()` always returns null.
- Released strong reference and triggered GC.
- Checked ReferenceQueue to detect when PhantomReference was enqueued.

Why
- To show how PhantomReferences differ from soft/weak references.
- Useful for safe cleanup of native resources (files, sockets, off-heap memory).
- Demonstrates advanced reference handling beyond GC reachability.

How
- Step 1: Create `NativeResource res = new NativeResource(1)`.
- Step 2: Wrap in `PhantomReference<>(res, queue)`.
- Step 3: Print `pr.get()` (always null).
- Step 4: Nullify strong reference and call `System.gc()`.
- Step 5: Sleep briefly to allow GC.
- Step 6: Poll ReferenceQueue, if enqueued → cleanup and call `clear()`.

Logic
- Inputs:
  - `NativeResource` created with id.
- Outputs:
  - Console log: `pr.get() = null`.
  - Console log: `"Phantom enqueued — cleanup now"` when GC clears resource.
- Flow:
  1. Strong + phantom references exist.
  2. Strong reference nulled → object becomes phantom-reachable.
  3. GC enqueues PhantomReference in ReferenceQueue.
  4. Application detects it and performs cleanup.
- Constraints:
  - GC timing is not deterministic; ReferenceQueue polling may return null if GC not run.
- Complexity:
  - O(1) for enqueue/dequeue operations.

Real-life applications
- PhantomReference used for post-mortem cleanup tasks.
- Manage large native resources (direct buffers, file handles).
- Used by JVM itself in DirectByteBuffer deallocation.

Notes
- `pr.get()` always returns null (unlike soft/weak references).
- Must use ReferenceQueue to detect GC of phantom-referenced objects.
- Part of Java’s 3-tier reference system:
  ✔ SoftReference → caches
  ✔ WeakReference → weak keys, listeners
  ✔ PhantomReference → cleanup hooks after finalization

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

Author: Someshdiwan

Section 25 Collections Frameworks/Map Interface/Garbage Collection/SoftReference vs WeakReference vs PhantomReference/src/PhantomDemo.java

@@ -0,0 +1,35 @@
+import java.lang.ref.PhantomReference;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+
+public class PhantomDemo {
+    static class NativeResource {
+        private final int id;
+        NativeResource(int id) { this.id = id; }
+        @Override public String toString() { return "NR#" + id; }
+    }
+    public static void main(String[] args) throws InterruptedException {
+        ReferenceQueue<NativeResource> queue = new ReferenceQueue<>();
+        NativeResource res = new NativeResource(1);
+
+        PhantomReference<NativeResource> pr = new PhantomReference<>(res, queue);
+
+        System.out.println("pr.get() = " + pr.get()); // always null
+        res = null; // drop strong reference
+
+        System.gc();
+        Thread.sleep(200);
+
+        Reference<? extends NativeResource> r = queue.poll();
+        if (r != null) {
+            System.out.println("Phantom enqueued — cleanup now");
+            r.clear();
+        }
+    }
+}
+
+/*
+•	SoftReference → Cache data that can be reloaded (but let JVM evict under memory pressure).
+•	WeakReference → Avoid preventing GC (e.g., weak keys in maps, listener cleanup).
+•	PhantomReference → Do resource cleanup safely (close files, free native memory).
+*/