/**
 * This example demonstrates basic object allocation in Java,
 * which implicitly relies on the JVM heap and will eventually
 * be subject to Garbage Collection. We create objects that
 * eventually become unreachable.
 */
public class ObjectAllocationDemo {

    public static void main(String[] args) {
        // Phase 1: Allocate several objects
        System.out.println("--- Phase 1: Initial Object Allocation ---");
        createObjects(5);
        System.out.println("Objects created. Some may be candidates for GC later.\n");

        // Phase 2: Create a local reference, then scope it out
        System.out.println("--- Phase 2: Scoping Objects for GC ---");
        {
            MyHeavyObject tempObject = new MyHeavyObject("Scoped Object");
            System.out.println("Inside scope: " + tempObject.getName());
            // 'tempObject' becomes unreachable after this block
        }
        System.out.println("Outside scope. 'Scoped Object' is now unreachable and eligible for GC.\n");

        // Phase 3: Create an object and explicitly nullify its reference
        System.out.println("--- Phase 3: Nullifying References ---");
        MyHeavyObject explicitNullObject = new MyHeavyObject("Explicit Null Object");
        System.out.println("Before nulling: " + explicitNullObject.getName());
        explicitNullObject = null; // Object is now unreachable
        System.out.println("Reference nullified. 'Explicit Null Object' is now unreachable.\n");

        // Demonstrate an object with a long-lived reference (not immediately collectible)
        System.out.println("--- Phase 4: Long-Lived Object ---");
        MyHeavyObject globalObject = new MyHeavyObject("Global Object");
        System.out.println("Global object: " + globalObject.getName() + " (still reachable via 'globalObject' variable)\n");

        // Hint to the GC (not guaranteed to run)
        System.out.println("--- Phase 5: Requesting GC Hint ---");
        System.gc(); // Requesting, not commanding. GC might or might not run.
        System.out.println("System.gc() called. Unreachable objects may be collected soon.\n");
    }

    public static void createObjects(int count) {
        for (int i = 0; i < count; i++) {
            new MyHeavyObject("Object_" + i);
            // These objects are immediately eligible for GC as no references are kept.
        }
    }
}

// A simple class to represent memory-consuming objects
class MyHeavyObject {
    private String name;
    private byte[] data; // Simulates some memory usage

    public MyHeavyObject(String name) {
        this.name = name;
        this.data = new byte[1024 * 1024]; // 1MB data
        System.out.println("Created: " + name + " (Allocated 1MB)");
    }

    public String getName() {
        return name;
    }

    @Override
    protected void finalize() throws Throwable {
        // This method is deprecated and not guaranteed to be called.
        // For demonstration, it shows when an object is about to be collected.
        System.out.println("Finalizing object: " + name);
    }
}

/**
 * This example illustrates the concept of object reachability,
 * which is central to the Java Garbage Collector's marking phase.
 * Objects are either reachable from a 'root' or they are not.
 */
public class MarkingPhaseDemo {

    // Static field: a GC root
    private static MyMarkableObject staticRootObject;

    public static void main(String[] args) {
        System.out.println("--- Marking Phase Simulation ---");

        // 1. Local variable: A GC root (for its lifetime)
        MyMarkableObject localRoot = new MyMarkableObject("Local Root");
        System.out.println("Created: " + localRoot.getName() + ", reachable via localRoot.");

        // 2. Object referenced by a root
        MyMarkableObject child1 = new MyMarkableObject("Child 1");
        localRoot.setReference(child1);
        System.out.println("Created: " + child1.getName() + ", reachable via localRoot -> Child 1.");

        // 3. Object referenced by another reachable object
        MyMarkableObject grandchild = new MyMarkableObject("Grandchild");
        child1.setReference(grandchild);
        System.out.println("Created: " + grandchild.getName() + ", reachable via localRoot -> Child 1 -> Grandchild.");

        // 4. Static field as a root
        staticRootObject = new MyMarkableObject("Static Root Child");
        System.out.println("Created: " + staticRootObject.getName() + ", reachable via staticRootObject (a GC root).");

        // 5. Object with no reachable references
        new MyMarkableObject("Unreachable Object A"); // Created and immediately unreachable
        System.out.println("Created: Unreachable Object A, immediately eligible for GC.");

        MyMarkableObject tempObject = new MyMarkableObject("Temp Object");
        System.out.println("Created: " + tempObject.getName() + ", reachable via tempObject.");
        tempObject = null; // 'Temp Object' becomes unreachable here
        System.out.println("'Temp Object' reference nullified, now eligible for GC.\n");

        // --- Simulate GC Marking Process ---
        System.out.println("\n--- GC Marking Process (Conceptual) ---");
        System.out.println("GC identifies 'roots' (localRoot, staticRootObject, etc.).");
        System.out.println("It traverses the object graph starting from these roots.");
        System.out.println("Objects reachable from roots are 'marked' as live.");
        System.out.println("\nExpected Live Objects:");
        System.out.println("- Local Root");
        System.out.println("- Child 1");
        System.out.println("- Grandchild");
        System.out.println("- Static Root Child");
        System.out.println("\nExpected Unreachable/Dead Objects (candidates for collection):");
        System.out.println("- Unreachable Object A");
        System.out.println("- Temp Object\n");

        // Request a GC run to demonstrate object finalization (if any)
        System.gc(); // Again, a hint, not a command.
        try {
            Thread.sleep(100); // Give GC a moment to potentially run
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

class MyMarkableObject {
    private String name;
    private MyMarkableObject reference;

    public MyMarkableObject(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setReference(MyMarkableObject reference) {
        this.reference = reference;
    }

    @Override
    protected void finalize() throws Throwable {
        // For demonstration, indicates when an object is being collected.
        System.out.println("Finalizing: " + name);
    }
}

/**
 * This example conceptually demonstrates the sweeping phase of the Java GC.
 * After objects are marked (or not marked, indicating they are dead),
 * the sweeping phase reclaims the memory occupied by the dead objects.
 * This simulation emphasizes memory fragmentation.
 */
public class SweepingPhaseDemo {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("--- Sweeping Phase Simulation ---");

        // Step 1: Create a series of objects, simulating memory allocation
        System.out.println("Creating initial objects, some will become unreachable...");
        MySweepObject[] objects = new MySweepObject[10];
        for (int i = 0; i < objects.length; i++) {
            objects[i] = new MySweepObject("Object_" + i, 1);
        }

        // Step 2: Simulate some objects becoming unreachable (dead)
        // We'll nullify alternate objects to create 'holes' (fragmentation)
        System.out.println("Nullifying alternate objects to simulate dead objects and fragmentation...");
        for (int i = 0; i < objects.length; i += 2) {
            objects[i] = null; // These objects are now unreachable
        }

        // Give the JVM a moment for potential weak/soft reference processing, etc.
        Thread.sleep(50);

        System.out.println("\n--- Conceptual Marking (happened before sweeping) ---");
        System.out.println("GC roots identified live objects (e.g., Object_1, Object_3, Object_5...). ");
        System.out.println("Unreachable objects (Object_0, Object_2, Object_4...) are unmarked.");

        // Step 3: Trigger GC to observe sweeping (finalization indicates collection)
        System.out.println("\n--- Executing Sweeping Phase (via System.gc()) ---");
        System.gc(); // Request GC to run the full cycle (mark, sweep, compact)
        Thread.sleep(200); // Allow time for GC to potentially run and finalize objects

        System.out.println("\nSweeping complete. Memory previously held by Object_0, Object_2, etc., is now reclaimed.");
        System.out.println("Observe potential memory fragmentation due to scattered free blocks.\n");

        // Step 4: Attempt new allocations after sweeping
        System.out.println("Attempting new object allocations after sweeping...");
        MySweepObject newObj1 = new MySweepObject("New_Object_A", 2); // Might fit into a larger hole
        MySweepObject newObj2 = new MySweepObject("New_Object_B", 1); // Might fit into a smaller hole
        MySweepObject newObj3 = new MySweepObject("New_Object_C", 3); // Might need compaction if no large enough contiguous block

        System.out.println("New objects created. Allocation strategy depends on free list management and fragmentation levels.");
    }
}

class MySweepObject {
    private String name;
    private byte[] data; // Simulates memory usage (MB)

    public MySweepObject(String name, int sizeMB) {
        this.name = name;
        this.data = new byte[sizeMB * 1024 * 1024];
        System.out.println("Allocated: " + name + " (Size: " + sizeMB + "MB)");
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("Finalizing (Sweeping): " + name);
    }
}

/**
 * This example conceptually demonstrates the impact of memory fragmentation
 * and the necessity of the Compacting Phase. We simulate creating and discarding
 * objects to intentionally fragment the heap, then discuss how compaction
 * would resolve this for subsequent, larger allocations.
 */
public class CompactingPhaseDemo {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("--- Compacting Phase Simulation ---");

        // Step 1: Create a pattern of fragmented memory
        System.out.println("Creating objects to intentionally fragment memory...");
        Object[] smallObjects = new Object[1000];
        for (int i = 0; i < 1000; i++) {
            smallObjects[i] = new byte[10 * 1024]; // 10KB objects
        }

        // Step 2: Nullify alternate objects to create 'holes'
        // This leaves small, scattered free blocks among live objects
        System.out.println("Nullifying alternate objects to create memory holes...");
        for (int i = 0; i < 1000; i += 2) {
            smallObjects[i] = null; // These become candidates for sweeping
        }

        // Request GC to run (mark and sweep, which creates fragmentation)
        System.gc();
        Thread.sleep(200); // Give time for GC to run
        System.out.println("Memory is now conceptually fragmented: small free blocks interspersed with live objects.\n");

        // Step 3: Attempt to allocate a large object
        System.out.println("Attempting to allocate a large object (e.g., 5MB array) into fragmented space...");
        try {
            // Without compaction, this might fail if no single contiguous 5MB block exists
            // even if total free memory > 5MB.
            byte[] largeObject = new byte[5 * 1024 * 1024]; // 5MB object
            System.out.println("Successfully allocated a large object without explicit compaction for demo. (JVM handled implicitly)");
            System.out.println("In real scenarios, severe fragmentation would trigger an OutOfMemoryError or a compaction cycle.\n");

            // Keep a reference to prevent immediate GC
            System.out.println("Reference to large object created: " + largeObject.length + " bytes.");
            // For demonstration, we could hold this reference and then release it.

        } catch (OutOfMemoryError e) {
            System.out.println("OutOfMemoryError encountered! Not enough contiguous space for the large object.");
            System.out.println("This is where the Compacting Phase becomes critical.\n");
        }

        System.out.println("\n--- Conceptual Compacting Phase ---");
        System.out.println("If fragmentation prevents allocation, GC initiates compaction.");
        System.out.println("Live objects are moved to one end of the heap, consolidating free space.");
        System.out.println("This creates a single, large contiguous block of free memory, ready for new allocations.");
        System.out.println("All references to moved objects must be updated to point to their new addresses.");
        System.out.println("This often involves another STW pause, but ensures future allocations are efficient.");
    }
}

/**
 * This code snippet illustrates how JVM flags can influence Garbage Collection behavior.
 * It also provides a conceptual outline of how to observe GC activity.
 *
 * To run this with specific GC flags:
 * Compile: javac GCTuningDemo.java
 * Execute (e.g., with Parallel GC): java -Xmx256m -Xms256m -XX:+UseParallelGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps GCTuningDemo
 * Execute (e.g., with G1 GC):        java -Xmx256m -Xms256m -XX:+UseG1GC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps GCTuningDemo
 */
public class GCTuningDemo {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("--- GC Tuning and Monitoring Concepts ---");

        // Simulate heavy object creation and discarding to trigger GC activity
        System.out.println("Generating short-lived objects to trigger Young Generation GC...");
        for (int i = 0; i < 10000; i++) {
            new byte[10 * 1024]; // 10KB object
            if (i % 1000 == 0) {
                System.out.print("."); // Progress indicator
            }
        }
        System.out.println("\nDone generating short-lived objects.\n");

        // Simulate long-lived object creation (promoted to Old Generation)
        System.out.println("Generating long-lived objects for Old Generation GC...");
        // Keep references to prevent immediate collection
        Object[] longLivedObjects = new Object[500];
        for (int i = 0; i < longLivedObjects.length; i++) {
            longLivedObjects[i] = new byte[50 * 1024]; // 50KB object
            if (i % 100 == 0) {
                System.out.print(".");
            }
        }
        System.out.println("\nDone generating long-lived objects.\n");

        // --- Conceptual Monitoring --- 
        // In a real scenario, we'd use external tools like JConsole, VisualVM,
        // or analyze GC logs generated by JVM flags.
        System.out.println("\n--- Monitoring GC Activity (Conceptual) ---");
        System.out.println("JVM arguments like -XX:+PrintGCDetails, -Xlog:gc* enable detailed GC logging.");
        System.out.println("Tools like JConsole, VisualVM, GCViewer visualize GC pauses, heap usage, and throughput.");
        System.out.println("Observing: Heap utilization, GC pause times, frequency of minor/major GCs.\n");

        System.out.println("--- Common GC Pitfalls ---");
        System.out.println("- **Memory Leaks:** Unintentionally holding references to objects no longer needed.");
        System.out.println("  (e.g., stale entries in a HashMap, unclosed resources).");
        System.out.println("- **Excessive GC Activity:** Too many objects created and discarded, leading to frequent pauses.");
        System.out.println("- **Long STW Pauses:** Resulting from full GCs on large heaps, especially with older collectors.");
        System.out.println("- **Ineffective Sizing:** Incorrect -Xmx (max heap), -Xms (initial heap), -XX:NewRatio settings.");
        System.out.println("\n--- Best Practices ---");
        System.out.println("- **Profile and Monitor:** Understand your application's memory footprint and GC behavior.");
        System.out.println("- **Choose Appropriate GC:** Select a collector that fits your latency/throughput requirements.");
        System.out.println("- **Object Pooling ( judiciously):** Reuse expensive objects, but avoid premature optimization.");
        System.out.println("- **Weak/Soft References:** Use for caches or non-critical data that can be collected.");
        System.out.println("- **Minimize Object Creation:** Especially in performance-critical loops.");
        System.out.println("- **Release Resources:** Close streams, connections promptly using try-with-resources.");

        // Keep references for a bit longer to simulate a running application
        Thread.sleep(1000);

        System.gc(); // Final GC hint
        Thread.sleep(100); 
    }
}