Two objects, one collected

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

/**
 * WARM-UP — 5 minutes. One concept. Hard to fail.
 *
 * Two identical objects. Both have their local variable set to null. One is
 * collected and one is not.
 *
 * TASKS
 *   1. Predict both answers before running.
 *   2. Run it.
 *   3. In a comment: nothing about the two objects differs. So what does?
 *   4. Add one line before the second probe so that it is collected too.
 */
public class Starter {

    /** A static field. Its class is a GC root, and classes are not unloaded. */
    static final List<Object> CACHE = new ArrayList<>();

    public static void main(String[] args) {
        Object loose = new Object();
        WeakReference<Object> probe1 = new WeakReference<>(loose);
        loose = null;

        System.out.println("no other reference : collected = " + collected(probe1));

        Object cached = new Object();
        WeakReference<Object> probe2 = new WeakReference<>(cached);
        CACHE.add(cached);
        cached = null;

        // TASK 4: one line here makes the next line print true.

        System.out.println("added to CACHE     : collected = " + collected(probe2));
        System.out.println("CACHE.size()       : " + CACHE.size());

        // Question to answer in a comment before you move on:
        // CACHE is `final`. Does that have anything to do with why the second
        // object survived? If not, what would?
    }

    /**
     * System.gc() is a hint, not a command, so asking once proves nothing.
     * This asks repeatedly with allocation pressure in between, and gives up
     * after a bounded number of attempts so it cannot hang.
     */
    static boolean collected(WeakReference<?> ref) {
        for (int attempt = 0; attempt < 50 && ref.get() != null; attempt++) {
            System.gc();
            byte[] churn = new byte[1 << 20];
            if (churn.length < 0) System.out.print("");
        }
        return ref.get() == null;
    }
}