feat(PhantomDemo1): add PhantomReference + ReferenceQueue cleanup example

What
- Added `PhantomDemo1` to demonstrate PhantomReference lifecycle.
- Created `NativeResource` wrapped in PhantomReference with ReferenceQueue.
- Showed that `pr.get()` always returns null.
- Dropped strong reference, triggered GC, and checked ReferenceQueue.
- Printed cleanup message if PhantomReference enqueued.

Why
- To illustrate safe post-GC cleanup without relying on finalizers.
- PhantomReference is essential for releasing non-Java resources (native memory, file handles).
- Complements SoftReference (caching) and WeakReference (maps/listeners).

How
- Step 1: Define `NativeResource` with `id`.
- Step 2: Instantiate and wrap in `PhantomReference<>(res, queue)`.
- Step 3: Print `pr.get()` → always null.
- Step 4: Nullify `res`, suggest GC via `System.gc()`.
- Step 5: Sleep briefly for GC.
- Step 6: Poll ReferenceQueue; if enqueued, log cleanup and call `clear()`.

Logic
- Inputs: new `NativeResource(1)`.
- Outputs:
  - Console log before GC: `before nulling res, pr.get() = null`.
  - After GC, either:
    - `"Phantom enqueued — do cleanup now for ..."`, or
    - `"No phantom enqueued yet."`.
- Flow:
  1. Strong + phantom refs exist.
  2. Strong ref dropped → object phantom-reachable.
  3. GC clears object → PhantomReference enqueued.
  4. Application detects and performs cleanup.
- Complexity: O(1) for ReferenceQueue operations.
- Non-determinism: GC may or may not run immediately, so queue.poll() may return null.

Real-life applications
- Safe cleanup of DirectByteBuffers (off-heap memory).
- Closing file handles or sockets after object reclamation.
- Resource tracking in JVM-managed frameworks.

Notes
- PhantomReference is the lowest-level reference type in Java’s hierarchy.
- Unlike soft/weak refs, `get()` always returns null.
- Cleanup must be done through ReferenceQueue.

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/PhantomDemo1.java

@@ -0,0 +1,40 @@
+import java.lang.ref.PhantomReference;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+
+public class PhantomDemo1 {
+    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);
+
+        // create phantom ref (get() returns null)
+        PhantomReference<NativeResource> pr = new PhantomReference<>(res, queue);
+
+        System.out.println("before nulling res, pr.get() = " + pr.get()); // always null
+
+        // drop strong ref
+        res = null;
+
+        // suggest GC
+        System.gc();
+        Thread.sleep(200);
+
+        // check queue - if enqueued, we can run cleanup
+        Reference<? extends NativeResource> r = queue.poll();
+        if (r != null) {
+            System.out.println("Phantom enqueued — do cleanup now for " + r);
+            // free native memory / close handles here
+            r.clear();
+        } else {
+            System.out.println("No phantom enqueued yet.");
+        }
+    }
+}
+
+// PhantomReference + ReferenceQueue example (cleanup).