What Makes an Object Garbage

Java asks a different question. Not “how many things point at this”, but “can this be reached from somewhere known to be alive”.

GC roots are the starting points. Things that are alive by definition:

• Local variables in every frame of every running thread’s stack.
• Static fields, which live in the method area.
• Objects currently being used as locks.
• References held by the JVM itself.

The collector starts at the roots and walks every reference it can follow, marking as it goes. Anything not marked at the end cannot be reached by any running code, whatever points at it.

Which settles the circular pair. Verified, with a weak reference watching one of them:

circular pair after gc: COLLECTED
strongly held        : still alive

The two objects point at each other and no path leads to them from any root. Unreachable, so collected. Being pointed at is not what keeps an object alive. Being reachable is.

Now for when, and it starts with one observation.

Most objects die very young. A StringBuilder inside a method. A boxed Integer in a loop. The intermediate list from a stream. Overwhelmingly, objects are made, used within a few microseconds, and never touched again.

A small number live for the whole program: the caches, the configuration, the connection pool.

Very few are in between. This is the generational hypothesis, and it is an observation about real programs rather than a rule.

So the heap is split to take advantage of it.

The trick is that the work is proportional to what survives, not to what was allocated. Almost everything in Eden is already dead, so a minor collection copies out the few survivors and then treats the whole space as empty. Allocating a million short lived objects costs almost nothing to clean up.

Answer from memory before opening the explanation. Then compare your rule with the answer and revisit the example if they differ.

1. Two objects point at each other and nothing else points at either one. Are they garbage?

   Show the answer

   Yes, and they are collected. Verified: make two objects, point each at the other, drop both variables, and a weak reference watching one of them reports it gone after the next collection.

   If Java counted references, neither would ever be freed. Each has a count of one, from the other, forever. That is the classic leak in reference counted languages.

   Java asks a different question: can this be reached from a GC root? Roots are things known to be live, like local variables in every running frame and static fields. The collector walks out from them and marks everything it can touch.

   Two objects in a ring with no path from any root are unreachable together, however many times they point at each other. Being pointed at is not what keeps an object alive. Being reachable is.

2. Why is the heap split into a young part and an old part?

   Show the answer

   Because of one observation that turns out to hold almost everywhere: most objects die very young. A string built inside a method, a temporary list, the box around an int. Nearly all of them are unreachable moments after being made.

   So the collector puts new objects in a small young area and collects that area often. Because almost everything there is already dead, it only has to copy out the few survivors. The work is proportional to what lived, not to what was allocated.

   Objects that keep surviving get promoted to the old area, which is collected rarely, because things that have already lived a long time usually keep living.

   Without the split, every collection would have to examine the entire heap, including the long lived objects you already know are fine.

3. How can a Java program leak memory when nobody allocates or frees anything?

   Show the answer

   By keeping references to things it no longer needs. The collector is doing exactly its job: those objects are reachable, so they stay.

   The usual shape is a collection that only ever grows. A static Map used as a cache with nothing ever removed, listeners added and never unregistered, a list of exceptions kept for later reporting.

   That last one is worse than it looks. Every exception holds a stack trace, and a trace holds references to the objects in those frames, so one stored exception can keep a whole graph alive.

   A leak here is never the collector failing. It is your code being more attached to something than you realised, and the fix is to remove the reference.

Write each solution in VS Code, predict its result, and then run the checks. Reading an example does not replace implementing it.

4 exercises110 pointsabout 110 minutes

class Ring {
    static boolean pairSurvives()
    static boolean heldPairSurvives()
    static int survivorsOfRing(int size)
    static boolean javaCountsReferences()
}

import java.lang.ref.*;
import java.util.*;

public class Ring {

    static class Node {
        Node other;
        byte[] bulk = new byte[256 * 1024];
    }

    static void collect() { }  // TODO: System.gc a few times, with small pauses

    // Two Nodes pointing only at each other, nothing outside reaching them.
    static boolean pairSurvives() { return true; }  // TODO

    // The same, but something outside still holds one of them.
    static boolean heldPairSurvives() { return false; }  // TODO

    // A ring of `size` Nodes, each pointing at the next, nothing pointing in.
    static int survivorsOfRing(int size) { return -1; }  // TODO

    // Does Java free an object when nothing points at it any more?
    static boolean javaCountsReferences() { return true; }  // TODO

    public static void main(String[] args) {
        // TODO: predict all three before running
    }
}

class Strengths {
    static boolean weakSurvivesOneCollection()
    static boolean softSurvivesOneCollection()
    static boolean strongSurvivesCollection()
    static int weakMapSizeAfterKeyDropped()
    static int weakMapSizeWhileKeyHeld()
    static String rightFor(String job)
}

import java.lang.ref.*;
import java.util.*;

public class Strengths {

    static void collect() { }  // TODO

    // PREDICT all three before running.
    static boolean weakSurvivesOneCollection()   { return true; }  // TODO
    static boolean softSurvivesOneCollection()   { return false; } // TODO
    static boolean strongSurvivesCollection()    { return false; } // TODO

    // A WeakHashMap entry with its key dropped, and one with the key still held.
    static int weakMapSizeAfterKeyDropped() { return -1; }  // TODO
    static int weakMapSizeWhileKeyHeld()    { return -1; }  // TODO

    // "soft", "weak" or "strong".
    static String rightFor(String job) { return ""; }  // TODO

    public static void main(String[] args) {
        // TODO: predict which survives one collection, then check
        // TODO: put the JVM under memory pressure with -Xmx128m and try again
    }
}

class Leak {
    static void reset()
    static int leakByCaching(int n)
    static int leakByStoringExceptions(int n)
    static int leakByListeners(int n)
    static boolean storedExceptionKeepsATrace()
    static boolean reachableFromARoot()
    static boolean collectorIsAtFault()
    static String fixFor(String leak)
    static int cacheSizeAfterCollection()
    static String whatEveryFixDoes()
}

import java.lang.ref.*;
import java.util.*;

public class Leak {

    static final Map<String, byte[]> cache = new HashMap<>();
    static final List<Exception> errors = new ArrayList<>();
    static final List<Object> listeners = new ArrayList<>();

    static void reset() { }    // TODO
    static void collect() { }  // TODO

    // Three leaks. All three are ordinary code that any review would pass.
    static int leakByCaching(int n)           { return 0; }  // TODO
    static int leakByStoringExceptions(int n) { return 0; }  // TODO
    static int leakByListeners(int n)         { return 0; }  // TODO

    // Does a stored exception hold anything beyond its own message?
    static boolean storedExceptionKeepsATrace() { return false; }  // TODO

    // Fill the cache, force a collection, and report the size.
    static int cacheSizeAfterCollection() { return -1; }  // TODO

    static boolean reachableFromARoot()  { return false; }  // TODO
    static boolean collectorIsAtFault()  { return true; }   // TODO

    static String fixFor(String leak)    { return ""; }  // TODO
    static String whatEveryFixDoes()     { return ""; }  // TODO

    public static void main(String[] args) {
        // TODO: run each leak with -Xmx128m and watch it fill
    }
}

class Watching {
    static void reset()
    static long totalCollections()
    static long totalPauseMillis()
    static List<String> collectorNames()
    static long collectionsForShortLived(int mb)
    static long collectionsForLongLived(int mb)
    static boolean generationalHypothesis()
}

import java.lang.management.*;
import java.util.*;

public class Watching {

    static final List<byte[]> longLived = new ArrayList<>();

    static void reset() { }  // TODO

    // Ask the JVM directly, rather than parsing log output.
    static long totalCollections()  { return 0; }  // TODO
    static long totalPauseMillis()  { return 0; }  // TODO
    static List<String> collectorNames() { return List.of(); }  // TODO

    // Allocate and immediately drop that many megabytes.
    static long collectionsForShortLived(int mb) { return 0; }  // TODO

    // Allocate and KEEP them, then clear afterwards.
    static long collectionsForLongLived(int mb) { return 0; }  // TODO

    static boolean generationalHypothesis() { return false; }  // TODO

    public static void main(String[] args) {
        // TODO: print the collector names and watch the counts move
        // TODO: run again with -Xlog:gc and read the lines it prints
        // TODO: try -XX:+UseSerialGC and -XX:+UseParallelGC and compare pauses
    }
}