Java Inner Class Memory Leak — Runnable Kept Session Alive

package io.thecodeforge.nestedclasses;

public class HttpRequest {

    private final String url;
    private final String method;
    private final int timeoutSeconds;

    // Private constructor forces callers to use the Builder
    private HttpRequest(Builder builder) {
        this.url = builder.url;
        this.method = builder.method;
        this.timeoutSeconds = builder.timeoutSeconds;
    }

    public String getUrl()           { return url; }
    public String getMethod()        { return method; }
    public int    getTimeoutSeconds(){ return timeoutSeconds; }

    @Override
    public String toString() {
        return method + " " + url + " (timeout=" + timeoutSeconds + "s)";
    }

    // Static nested class — belongs to HttpRequest conceptually,
    // but needs NO access to any HttpRequest instance while building.
    public static class Builder {\n\n        private String url    = \"\";\n        private String method = \"GET\";     // sensible default\n        private int    timeoutSeconds = 30; // sensible default\n\n        public Builder url(String url) {\n            this.url = url;\n            return this;  // enables method chaining\n        }\n\n        public Builder method(String method) {\n            this.method = method;\n            return this;\n        }\n\n        public Builder timeoutSeconds(int seconds) {\n            this.timeoutSeconds = seconds;\n            return this;\n        }\n\n        // Creates the outer-class instance using 'this' Builder\n        public HttpRequest build() {\n            if (url.isBlank()) {\n                throw new IllegalStateException(\"URL must not be blank\");\n            }\n            return new HttpRequest(this); // passes itself to the private constructor\n        }\n    }\n\n    public static void main(String[] args) {\n        // No HttpRequest instance needed to create a Builder\n        HttpRequest request = new HttpRequest.Builder()\n                .url(\"https://api.thecodeforge.io/articles\")\n                .method(\"POST\")\n                .timeoutSeconds(10)\n                .build();\n\n        System.out.println(request);\n    }\n}",
        "output": "POST https://api.thecodeforge.io/articles (timeout=10s)"
      }

package io.thecodeforge.nestedclasses;

import java.util.Iterator;
import java.util.NoSuchElementException;

// A simple inclusive integer range that can be iterated
public class NumberRange implements Iterable<Integer> {

    private final int start;
    private final int end;

    public NumberRange(int start, int end) {\n        if (start > end) {\n            throw new IllegalArgumentException(\"start must be <= end\");\n        }\n        this.start = start;\n        this.end   = end;\n    }\n\n    @Override\n    public Iterator<Integer> iterator() {\n        // Returns a new RangeIterator tied to THIS NumberRange instance\n        return new RangeIterator();\n    }\n\n    // Non-static inner class — it needs to read 'start' and 'end'\n    // from the enclosing NumberRange instance. Making this static\n    // would require passing start/end explicitly; inner class reads them for free.\n    private class RangeIterator implements Iterator<Integer> {\n\n        private int current = start; // directly reads outer instance field\n\n        @Override\n        public boolean hasNext() {\n            return current <= end;  // reads outer instance field 'end'\n        }\n\n        @Override\n        public Integer next() {\n            if (!hasNext()) {\n                throw new NoSuchElementException(\n                    \"No more values in range [\" + start + \", \" + end + \"]\"\n                );\n            }\n            return current++;\n        }\n    }\n\n    public static void main(String[] args) {\n        NumberRange range = new NumberRange(1, 5);\n\n        // Enhanced for-loop uses the iterator() method under the hood\n        for (int number : range) {\n            System.out.print(number + \" \");\n        }\n        System.out.println();\n\n        // Each call to iterator() creates a fresh, independent RangeIterator\n        Iterator<Integer> it1 = range.iterator();\n        Iterator<Integer> it2 = range.iterator();\n        System.out.println(\"it1 first: \" + it1.next()); // advances it1 only\n        System.out.println(\"it2 first: \" + it2.next()); // it2 still starts at 1\n    }\n}",
        "output": "1 2 3 4 5 \nit1 first: 1\nit2 first: 1"
      }

package io.thecodeforge.nestedclasses;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class SortingDemo {

    public static void main(String[] args) {

        List<String> cities = Arrays.asList(
            "Tokyo", "Berlin", "São Paulo", "Lagos", "Melbourne"
        );

        // ── LOCAL CLASS EXAMPLE ──────────────────────────────────────────
        // Suppose we want a Comparator that sorts by string length first,
        // then alphabetically. This logic is only needed in this method.
        final boolean ascending = true; // effectively final — captured below

        class LengthThenAlphaComparator implements Comparator<String> {\n\n            @Override\n            public int compare(String a, String b) {\n                // Uses 'ascending' from the enclosing method scope\n                int lengthDiff = Integer.compare(a.length(), b.length());\n                if (lengthDiff != 0) {\n                    return ascending ? lengthDiff : -lengthDiff;\n                }
                return a.compareTo(b); // alphabetical tiebreak
            }
        }

        List<String> citiesCopy = new java.util.ArrayList<>(cities);
        citiesCopy.sort(new LengthThenAlphaComparator());
        System.out.println("Local class sort:     " + citiesCopy);

        // ── ANONYMOUS CLASS EXAMPLE ──────────────────────────────────────
        // Same comparator, but written inline as an anonymous class.
        // Useful when you won't reuse the name anywhere in this method.
        citiesCopy = new java.util.ArrayList<>(cities);
        citiesCopy.sort(new Comparator<String>() {
            @Override
            public int compare(String a, String b) {\n                // Sorts purely by length descending — longest city name first\n                return Integer.compare(b.length(), a.length());\n            }
        });
        System.out.println("Anonymous class sort: " + citiesCopy);

        // ── LAMBDA (for contrast) ────────────────────────────────────────
        // A lambda replaces a single-abstract-method anonymous class.
        // Clean, concise. Use lambdas over anonymous classes for SAM interfaces.
        citiesCopy = new java.util.ArrayList<>(cities);
        citiesCopy.sort((a, b) -> a.compareTo(b));
        System.out.println("Lambda sort:          " + citiesCopy);
    }
}

package io.thecodeforge.nestedclasses;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.stream.IntStream;

public class MemoryCostExample {

    private final int id;

    public MemoryCostExample(int id) {
        this.id = id;
    }

    // Non-static inner class — each instance holds a reference to outer
    public class InnerIterator implements Iterator<Integer> {
        private int current = 0;
        @Override
        public boolean hasNext() { return current < id; } // accesses outer id
        @Override
        public Integer next() { return current++; }
    }

    public Iterator<Integer> getInnerIterator() {
        return new InnerIterator();
    }

    public static void main(String[] args) throws InterruptedException {
        List<Iterator<Integer>> iterators = new ArrayList<>();

        // Simulate high-throughput creation of inner class instances
        IntStream.range(0, 1_000_000).forEach(i -> {\n            MemoryCostExample outer = new MemoryCostExample(i % 100);
            // Each InnerIterator holds a reference to its outer instance
            // Outer instances are not shared, so 1M outer + 1M inner instances
            iterators.add(outer.getInnerIterator());
        });

        System.out.println("Created " + iterators.size() + " inner class instances.");
        // Now all outer instances are reachable because inner instances hold them
        // This is a memory leak: outer instances cannot be GC'd
        // Even if we null out the objects in iterators later, the outer refs kept
        // Fix: use static nested class and pass only needed data

        // Wait for GC to show they are still alive
        System.gc();
        Thread.sleep(1000);
        System.out.println("After GC, iterators still size: " + iterators.size());
    }
}

package io.thecodeforge.nestedclasses;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

// Demonstrates static nested class (Transaction) and
// non-static inner class (TransactionView) in one cohesive example
public class BankAccount {

    private final String accountNumber;
    private double balancePence; // stored in pence to avoid floating-point drift
    private final List<Transaction> history = new ArrayList<>();

    public BankAccount(String accountNumber, double openingBalancePounds) {\n        this.accountNumber = accountNumber;\n        this.balancePence  = Math.round(openingBalancePounds * 100);\n    }

    public void deposit(double amountPounds) {
        long amountPence = Math.round(amountPounds * 100);
        balancePence += amountPence;
        // Transaction is a value object — no need to know which account created it
        history.add(new Transaction("DEPOSIT", amountPence, balancePence));
    }

    public void withdraw(double amountPounds) {
        long amountPence = Math.round(amountPounds * 100);
        if (amountPence > balancePence) {
            throw new IllegalStateException("Insufficient funds");
        }
        balancePence -= amountPence;
        history.add(new Transaction("WITHDRAWAL", amountPence, balancePence));
    }

    // Returns a read-only view tied to THIS account instance
    public TransactionView getView() {
        return new TransactionView(); // creates inner class instance via outer instance
    }

    // ── STATIC NESTED CLASS ─────────────────────────────────────────────────
    // Transaction is a pure value/data object. It records what happened.
    // It doesn't need to call any method on BankAccount, so it's static.
    public static class Transaction {
        private final String          type;
        private final long            amountPence;
        private final long            balanceAfterPence;
        private final LocalDateTime   timestamp;

        private Transaction(String type, long amountPence, long balanceAfterPence) {\n            this.type              = type;\n            this.amountPence       = amountPence;\n            this.balanceAfterPence = balanceAfterPence;\n            this.timestamp         = LocalDateTime.now();\n        }

        @Override
        public String toString() {
            return String.format("%-12s £%6.2f  (balance: £%.2f)",
                type, amountPence / 100.0, balanceAfterPence / 100.0);
        }
    }

    // ── NON-STATIC INNER CLASS ──────────────────────────────────────────────
    // TransactionView is a *view of this specific account*.
    // It reads 'accountNumber', 'balancePence', and 'history' from the
    // enclosing BankAccount instance — it genuinely needs the outer instance.
    public class TransactionView {

        public void printStatement() {
            // Directly accesses outer instance's private fields — no getters needed
            System.out.println("Account: " + accountNumber);
            System.out.printf ("Balance: £%.2f%n", balancePence / 100.0);
            System.out.println("──────────────────────────────────────────");
            List<Transaction> snapshot = Collections.unmodifiableList(history);
            if (snapshot.isEmpty()) {
                System.out.println("No transactions yet.");
            } else {
                snapshot.forEach(System.out::println);
            }
        }
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount("GB29-NWBK-1234", 500.00);
        account.deposit(150.75);
        account.withdraw(42.00);
        account.deposit(10.00);

        // Getting a view — inner class instance is created through the outer instance
        TransactionView view = account.getView();
        view.printStatement();

        // A Transaction can be used standalone — it's a static nested class
        BankAccount.Transaction sampleTx =
            new BankAccount.Transaction("REFUND", 500, 65075); // only possible if public
        // Note: constructor is private here, so this line would not compile.
        // Shown to illustrate the syntax for public static nested classes.
    }
}

// io.thecodeforge — java tutorial

class PaymentGateway {
    private int retryCount = 3;

    class Transaction {
        private int retryCount = 0; // shadows outer

        void process() {
            // BUG: uses inner's retryCount
            System.out.println(retryCount);
            // FIX: use outer explicitly
            System.out.println(PaymentGateway.this.retryCount);
        }
    }

    public static void main(String[] args) {
        PaymentGateway pg = new PaymentGateway();
        Transaction tx = pg.new Transaction();
        tx.process();
    }
}

// io.thecodeforge — java tutorial

import java.io.*;

class Session {
    byte[] payload = new byte[50_000_000];

    class UserToken implements Serializable { // BUG
        String tokenId;
    }

    static class SafeToken implements Serializable { // FIX
        String tokenId;
    }
}

public class SerializationMeltdown {
    public static void main(String[] args) throws Exception {
        Session session = new Session();
        Session.UserToken bad = session.new UserToken();
        bad.tokenId = "abc";

        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("token.ser"))) {
            oos.writeObject(bad); // serializes entire session + 50MB payload
        }
        System.out.println("Serialized (and you just leaked 50MB)");
    }
}

// io.thecodeforge — java tutorial

public class Outer {
    class Inner {
        void show() {
            System.out.println("Inside Inner");
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.new Inner();
        inner.show();
    }
}

// io.thecodeforge — java tutorial

// Don't do this — hidden and untestable
public class ShoppingCart {
    static class LineItem {
        String product;
        int qty;
    }
}

// Do this — explicit and testable
public class LineItem {
    String product;
    int qty;
}

// io.thecodeforge — java tutorial

public class Outer {
    private int secret = 42;

    class Inner {
        int read() { return secret; } // triggers synthetic accessor
    }

    public static void main(String[] args) {
        Outer o = new Outer();
        Inner i = o.new Inner();
        System.out.println(i.read());
    }
}

// io.thecodeforge — java tutorial

// Before: inner class causes coupling
// After: top-level class is independently testable

class Outer {
    // no inner class here
}

class Helper {
    private final Outer owner;

    Helper(Outer owner) {
        this.owner = owner;
    }

    // logic extracted from former inner class
    public String greet() {
        return "Hello from its own file";
    }

    public static void main(String[] args) {
        System.out.println(new Helper(new Outer()).greet());
    }
}

// io.thecodeforge — java tutorial
// 25 lines max
public class OuterClass {
    private int x = 10;

    class Inner {
        void show() {
            System.out.println(x); // accesses outer field
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.Inner inner = outer.new Inner();
        inner.show();
        // Compiles to: OuterClass.class, OuterClass$Inner.class
    }
}

// io.thecodeforge — java tutorial
// 25 lines max
public class TopLevelClass {
    private static class Helper {
        static String greet(String name) {
            return "Hello, " + name;
        }
    }

    public static void main(String[] args) {
        System.out.println(Helper.greet("World"));
        // Better: extract Helper to its own file
    }
}