Practice Questions — Java Memory Model and Garbage Collection

public class ObjectCounter {
    private static int creationCount = 0;
    private String name;

    ObjectCounter(String name) {
        this.name = name;
        creationCount++;
        System.out.println("Created: " + name + " (total: " + creationCount + ")");
    }

    public static void main(String[] args) {
        ObjectCounter a = new ObjectCounter("A");
        ObjectCounter b = new ObjectCounter("B");
        ObjectCounter c = new ObjectCounter("C");
        System.out.println("Creation count: " + creationCount);

        a = null;
        b = null;
        System.gc();
        System.out.println("After nullifying A and B:");
        System.out.println("Creation count (static): " + creationCount);
        System.out.println("Only C is still reachable: " + c.name);
    }
}

public class GCAnalyzer {
    static class Node { Node next; String name;
        Node(String n) { name = n; }
    }

    public static void main(String[] args) {
        // Case 1: Reference set to null
        Node n1 = new Node("A");
        n1 = null; // A eligible
        System.out.println("Case 1 (null): 1 eligible");

        // Case 2: Reference reassigned
        Node n2 = new Node("B");
        n2 = new Node("C"); // B eligible, C alive
        System.out.println("Case 2 (reassign): 1 eligible (B)");

        // Case 3: Scope exit
        createAndReturn();
        System.out.println("Case 3 (scope): 1 eligible (D)");

        // Case 4: Circular with no external reference
        Node e = new Node("E");
        Node f = new Node("F");
        e.next = f;
        f.next = e;
        e = null;
        f = null; // E-F island of isolation
        System.out.println("Case 4 (circular): 2 eligible (E, F)");

        System.gc();
    }

    static void createAndReturn() {
        Node d = new Node("D");
    }
}

public class MemoryMonitor {
    static void printMem(String label) {
        Runtime rt = Runtime.getRuntime();
        long total = rt.totalMemory() / (1024 * 1024);
        long free = rt.freeMemory() / (1024 * 1024);
        long used = total - free;
        System.out.printf("%s: Used=%dMB, Free=%dMB, Total=%dMB%n", label, used, free, total);
    }

    public static void main(String[] args) {
        printMem("Initial");

        Object[] data = new Object[500_000];
        for (int i = 0; i < data.length; i++) {
            data[i] = new byte[50];
        }
        printMem("After allocation");

        data = null;
        System.gc();
        printMem("After GC");
    }
}

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

public class WeakCache<K, V> {
    private final Map<K, WeakReference<V>> cache = new HashMap<>();

    public void put(K key, V value) {
        cache.put(key, new WeakReference<>(value));
    }

    public V get(K key) {
        WeakReference<V> ref = cache.get(key);
        return (ref != null) ? ref.get() : null;
    }

    public static void main(String[] args) {
        WeakCache<String, String> cache = new WeakCache<>();
        String value = new String("ImportantData");
        cache.put("key1", value);

        System.out.println("Before GC: " + cache.get("key1"));
        System.gc();
        System.out.println("After GC (strong ref alive): " + cache.get("key1"));

        value = null; // remove strong reference
        System.gc();
        System.out.println("After GC (no strong ref): " + cache.get("key1"));
    }
}

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

public class LeakDetector {
    private static final List<byte[]> leakyCache = new ArrayList<>();

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

    public static void main(String[] args) {
        System.out.println("=== Demonstrating Memory Leak ===");
        for (int i = 1; i <= 500; i++) {
            leakyCache.add(new byte[10_000]); // ~10KB per entry
            if (i % 100 == 0) {
                System.gc();
                System.out.println("Iteration " + i + ": used=" + usedMB() + "MB, cache=" + leakyCache.size());
            }
        }

        System.out.println("\n=== Fixing the Leak ===");
        leakyCache.clear();
        System.gc();
        System.out.println("After clear: used=" + usedMB() + "MB, cache=" + leakyCache.size());
    }
}