Stack vs Heap Memory — GC Failed to Reclaim Payment Cache

package io.thecodeforge.memory;

public class HeapMemoryDemo {

    // Object fields live on the heap (part of the object)
    static class PaymentRecord {
        String    paymentId;    // reference on heap; String object also on heap
        int       amountPence;  // primitive stored directly in the object on heap
        boolean   processed;
    }

    public static void main(String[] args) {
        // 'record' reference: on main()'s stack frame (4-8 bytes)
        // PaymentRecord object: on the heap (size = fields + object header ~16 bytes)
        PaymentRecord record = new PaymentRecord();
        record.paymentId   = "pay-42";
        record.amountPence = 10_000;   // £100.00
        record.processed   = false;

        process(record);  // passes the reference — NOT a copy of the object

        record = null;    // No more references → object eligible for GC
    } // 'record' reference popped from stack; object waits for GC

    static void process(PaymentRecord r) {
        // 'r' is a copy of the reference on THIS frame's stack
        // r.processed = true modifies the SAME object on the heap
        r.processed = true;
        System.out.println("Processed: " + r.paymentId);
    } // 'r' reference gone; heap object still exists (main() still holds it)

    // JVM flags for memory tuning:
    // java -Xms512m -Xmx2g -Xss512k -jar app.jar
    //      ^^^^^^^^  ^^^^   ^^^^^^^  
    //      init heap  max   stack per thread
}

package io.thecodeforge.memory;

public class PreventStackOverflow {

    // RISKY: recursive JSON-like parser without depth limit
    static void parseNested(JsonNode node) {
        if (node.isObject()) {
            for (JsonNode child : node) {
                parseNested(child); // no depth check!
            }
        }
    }

    // SAFE: iterative version using explicit stack
    static void parseIteratively(JsonNode root) {
        Deque<JsonNode> stack = new ArrayDeque<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            JsonNode node = stack.pop();
            if (node.isObject()) {
                for (JsonNode child : node) {
                    stack.push(child);
                }
            }
        }
    }

    // SAFE: recursive with depth guard
    static void parseSafely(JsonNode node, int depth) {
        if (depth > 100) throw new RuntimeException("Nesting too deep");
        if (node.isObject()) {
            for (JsonNode child : node) {
                parseSafely(child, depth + 1);
            }
        }
    }

    public static void main(String[] args) {
        // Simulate deep JSON - see how parseNested fails
        // Use parseIteratively or parseSafely instead
    }
}

package io.thecodeforge.memory;

import java.util.*;

public class OOMDebug {

    static class Event {
        long timestamp;
        byte[] payload = new byte[1024]; // 1KB each
    }

    static Map<String, Event> eventCache = new HashMap<>();

    public static void main(String[] args) {
        // Simulate a memory leak: events are added but never removed
        for (int i = 0; i < 1_000_000; i++) {
            eventCache.put("event-" + i, new Event());
        }
        // This will throw OutOfMemoryError unless heap is huge
    }
}

package io.thecodeforge.memory;

public class ThreadSafety {

    static class SharedCounter {
        int count; // heap, shared, needs synchronization

        synchronized void increment() {
            count++; // safe with synchronized
        }
    }

    public static void main(String[] args) throws Exception {
        SharedCounter counter = new SharedCounter();

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start(); t2.start();
        t1.join(); t2.join();

        System.out.println(counter.count); // always 2000 with synchronized
    }

    // Compare: local variable is thread-safe
    static void localSum() {
        int local = 0; // on this thread's stack
        for (int i = 0; i < 1000; i++) {
            local++;
        }
        // No other thread can see 'local'
    }
}