reachability

the picture

you know how people say "the GC frees objects nobody uses"? that's not quite it. the GC has no idea what you "use". it only knows what you can reach.

think of a fairground full of balloons. kids hold strings (the roots), balloons are tied to other balloons (fields pointing at objects). at closing time, staff don't hunt for abandoned balloons. they start at every kid's hand, follow every string, and tag every balloon they get to. anything untagged floats away, including two balloons that are tied to each other with nobody holding either.

see the direction? reachability flows from roots, along references. pointing at something alive doesn't make you alive (that's K). being pointed at by something dead doesn't either (that's I, kept company by H).

what counts as a root

in HotSpot, marking starts from all of these:

thread stacks

every local variable and operand in every frame of every live thread. the big one.

static fields

reachable through their class, which is reachable through its class loader. the app class loader never goes away, so neither do your statics.

live threads

a started, not-yet-finished Thread is a root itself. so is everything its Runnable holds.

JNI references

objects native code is holding on to, through local or global JNI handles.

held monitors

an object some thread is synchronized on right now.

JVM internals

the system class loader, preallocated exceptions like the OutOfMemoryError it needs to throw when there's no memory left, and friends.

class Node { Node next; }
 
Node a = new Node();
Node b = new Node();
a.next = b;
b.next = a;
a = null;
b = null;

references that don't keep things alive

sometimes you want to point at an object without keeping it alive: a cache entry that should vanish under memory pressure, metadata attached to an object you don't own, a native resource that should be freed once its owner is gone. java.lang.ref gives you three weaker kinds of reference. the GC treats each one differently.

here's the classic weak one in action. WeakHashMap holds its keys weakly, so an entry disappears once nothing else holds the key:

import java.util.*;
 
void main() throws Exception {
    Map<Object, String> labels = new WeakHashMap<>();
    Object user = new Object();
    labels.put(user, "ada");
    IO.println("before gc: " + labels.size());
 
    user = null;          // the only strong reference is gone
    System.gc();          // a hint, not an order
    Thread.sleep(100);    // give the reference handler thread a moment
 
    IO.println("after gc:  " + labels.size());
}

on my machine (jdk 25, every collector i tried) it prints before gc: 1 then after gc: 0. but notice what it took. System.gc() is only a request: -XX:+DisableExplicitGC turns it into a no-op, and the spec lets the JVM ignore it. and the sleep is real: without it, G1 printed after gc: 1 every time. the GC had already cleared the weak reference, but WeakHashMap only drops the entry when it polls its ReferenceQueue, and a JVM thread called the reference handler hadn't queued it yet. weak means "eventually", not "now".

cleaning up after an object

finalize() was java's original "run this when the object dies" hook. it's deprecated for removal since java 18 (JEP 421), and you can already switch it off with --finalization=disabled. it was bad in every way: it ran on an unknown thread at an unknown time (or never), an object with a finalizer needed at least two GCs to be reclaimed, and finalize() could store this somewhere and bring the object back to life.

the replacement is java.lang.ref.Cleaner (java 9), built on phantom references. you register an object and a cleanup action. when the object becomes phantom reachable, a cleaner thread runs the action. and you should still close things explicitly: the cleaner is the safety net, not the plan.

import java.lang.ref.Cleaner;
 
static final Cleaner CLEANER = Cleaner.create();
 
// the cleanup state. it must NOT point back at the Buffer, or the Buffer never dies.
record Release(int id) implements Runnable {
    public void run() { IO.println("released native memory of buffer " + id); }
}
 
static class Buffer implements AutoCloseable {
    private final Cleaner.Cleanable cleanable;
    Buffer(int id) { cleanable = CLEANER.register(this, new Release(id)); }
    public void close() { cleanable.clean(); }   // runs the action at most once
}
 
void main() throws Exception {
    try (var a = new Buffer(1)) {
        IO.println("using buffer 1");
    }
    new Buffer(2);            // forgot to close it
    System.gc();
    Thread.sleep(100);
    IO.println("done");
}

what i got:

using buffer 1
released native memory of buffer 1
released native memory of buffer 2
done

buffer 1 was released by close(), right when the try ended. buffer 2 was released by the cleaner, after a GC noticed nobody could reach it. same action, and clean() guarantees it runs at most once either way.