Measure your own stack

import java.util.*;

/**
 * CHALLENGE — 20 minutes.
 *
 * "How deep can Java recurse?" has no single answer, and this exercise is
 * about making that concrete rather than accepting it.
 *
 * TASKS
 *   1. Run it as-is. Note the depth.
 *   2. Fill in depthOnStackOf() so the probe runs on a thread with the
 *      requested stack size, and measure 256 KB, 1 MB and 8 MB.
 *   3. Run the SAME size three times. The numbers differ. Explain why in a
 *      comment. (Hint: something compiles the method partway through.)
 *   4. Implement descendWithLocals() — same recursion, but with several
 *      unused long locals — and measure it. It should reach a lower depth.
 *      Say why in a comment.
 *   5. Prove the blast radius: let a worker thread overflow, catch it there,
 *      and show main is unharmed afterwards.
 */
public class Starter {

    static int depth;

    static void descend() {
        depth++;
        descend();
    }

    /** TASK 4: the same recursion, but each frame carries more locals. */
    static void descendWithLocals() {
        // TODO: declare several long locals that the recursion actually uses,
        // then recurse. Unused locals may be optimised away, so use them.
        throw new UnsupportedOperationException("task 4");
    }

    /**
     * TASK 2: run descend() on a thread with exactly this stack size and
     * return the depth it reached.
     *
     * Thread(ThreadGroup, Runnable, String, long) is the constructor you want.
     * Remember to join() — otherwise you read `depth` before it is finished.
     */
    static int depthOnStackOf(long stackBytes) throws Exception {
        // TODO
        depth = 0;
        descend();          // wrong: this runs on main, ignoring stackBytes
        return depth;
    }

    public static void main(String[] args) throws Exception {
        // Step 1, as shipped: whatever main's stack happens to be.
        depth = 0;
        try {
            descend();
        } catch (StackOverflowError e) {
            System.out.println("depth on main's own stack : " + depth);
        }

        // Step 2, once depthOnStackOf works:
        // System.out.println("256 KB : " + depthOnStackOf(256 * 1024));
        // System.out.println("1 MB   : " + depthOnStackOf(1024 * 1024));
        // System.out.println("8 MB   : " + depthOnStackOf(8 * 1024 * 1024));

        // Step 5: one thread overflows; main must survive it.
        System.out.println("main is still running     : true");
    }
}