Where Everything Actually Lives

A running JVM keeps memory in areas with different rules and different lifetimes.

The stack is per thread, and it is why locals are safe.

Every method invocation has a frame in the JVM execution model, as described in Section 5.1. The frame holds parameters, locals and return state. A JIT may inline a call physically while preserving the same observable behaviour.

No collector is involved. Popping a frame is one pointer moving, and that is the whole cleanup.

Two threads running the same method have two stacks and two frames. Neither can reach the other’s locals, which is a guarantee you get for nothing.

The heap is shared, and that is where objects go.

Student s = new Student("Aditya", 101);

Two things happen. The object is built on the heap. A reference to it goes in the frame.

When the method ends, the reference dies with the frame. The object does not. It stays on the heap until nothing can reach it any more, and then the garbage collector takes it at some later moment of its choosing.

That gap is why return s works at all. The object was never tied to the method that made it.

The method area holds the classes themselves.

Not the objects, the blueprints. The bytecode of every method, the field definitions, the static variables, the constant pool. Loaded once when the class is first used, and shared by every thread and every instance.

There is exactly one copy of Student’s toString bytecode no matter how many Student objects you make. Static fields live here too, which is why every instance sees the same one.

The string pool is in here, and it is where "Aditya" from the problem lives. That is Section 9.1 with an address attached.

The PC register is one number per thread.

Which instruction that thread is executing. It exists because threads get interrupted and have to be resumed exactly where they stopped. One per thread, and you never touch it.

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

1. `int x = 5;` inside a method, and `new Student()` inside the same method. Where does each one live, and when does each one die?

   Show the answer

   x is four bytes inside that method's stack frame. It dies at the closing brace, because the whole frame is discarded when the method returns. Nothing collects it and nothing needs to.

   The Student object is on the heap. The reference to it is in the frame and dies with the frame, but the object does not. It stays until nothing can reach it any more, and then the collector takes it whenever it next runs.

   That gap is the point. Return the reference and the object outlives the method that made it. Return an int and you return a copy of a number, which is Section 6.3 again.

2. Two threads run the same method at the same time. What do they share and what do they not?

   Show the answer

   Each thread has its own stack. Two threads in the same method have two frames, two copies of every local variable, and neither can see the other's. Locals are private to a thread for free, without any effort on your part.

   They share the heap and the method area. Every object either one creates is visible to both, and so is every static field.

   That single split is the whole reason Phase XIV exists. A local is safe because nobody else can reach it. Anything on the heap is reachable by every thread at once, and that is where the trouble starts.

3. Ten million ints in an `int[]` against ten million in an `Integer[]`. How much heap does each take, and where does the difference come from?

   Show the answer

   Measured on Java 21: 40 MB against 192 MB.

   The int[] is one object holding ten million four byte values, packed together. Forty megabytes and one header.

   The Integer[] is one array of ten million references, and ten million separate objects for those references to point at. Each Integer carries a header as well as its four bytes of number, which is most of the extra.

   This is the cost that made IntStream and IntUnaryOperator worth having in Phase XI, and it is why ArrayList beat LinkedList at appending in Phase X.

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

4 exercises100 pointsabout 95 minutes

class Weigh {
    static long usedMb()
    static long primitiveMb(int n)
    static long boxedMb(int n)
    static int bytesPerPrimitive()
    static int bytesPerBoxed()
    static long predictedBoxedMb(int n)
    static boolean liveReferenceNeeded()
}

public class Weigh {

    static Object keep;   // hold a live reference while measuring

    static long usedMb() { return 0; }  // TODO

    static long primitiveMb(int n) { return 0; }  // TODO: an int[n], filled
    static long boxedMb(int n)     { return 0; }  // TODO: an Integer[n], filled

    // Work these out from the layout, do not measure them.
    static int bytesPerPrimitive() { return 0; }  // TODO
    static int bytesPerBoxed()     { return 0; }  // TODO: the object AND the reference to it
    static long predictedBoxedMb(int n) { return 0; }  // TODO

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

    public static void main(String[] args) {
        // TODO: measure both at 10_000_000, with -Xms3g -Xmx3g
    }
}

class RunOut {
    static void deeper(int depth)
    static int stackDepth()
    static String fillStack()
    static String fillHeap(int mbLimit)
    static String flagFor(String failure)
    static boolean sameArea()
}

import java.util.*;

public class RunOut {

    static int deepest = 0;

    static void deeper(int depth) { }  // TODO: recurse, recording the depth

    static int stackDepth() { return 0; }  // TODO: catch the error, return the depth

    static String fillStack() { return ""; }  // TODO: the simple name of what came out

    // Fill the HEAP instead, up to a limit in megabytes. Run with -Xmx128m.
    static String fillHeap(int mbLimit) { return ""; }  // TODO

    // Which JVM flag moves each limit?
    static String flagFor(String failure) { return ""; }  // TODO

    // Do the two failures come from the same memory area?
    static boolean sameArea() { return true; }  // TODO

    public static void main(String[] args) {
        // TODO: find your stack depth, then run again with -Xss256k and -Xss4m
        // TODO: fill the heap with -Xmx128m so it does not take all day
    }
}

class WhichArea {
    static boolean twoLiteralsAreOneObject()
    static boolean literalEqualsNew()
    static boolean internMatchesLiteral()
    static boolean smallIntegersAreShared()
    static boolean largeIntegersAreShared()
    static int sharedCounterAfter(int objects)
    static int instanceFieldOfEach()
    static String areaOf(String what)
}

public class WhichArea {

    static int counter = 0;      // which area?
    int instanceField = 0;       // which area?

    // PREDICT all five before running.
    static boolean twoLiteralsAreOneObject() { return false; }  // TODO
    static boolean literalEqualsNew()        { return false; }  // TODO
    static boolean internMatchesLiteral()    { return false; }  // TODO
    static boolean smallIntegersAreShared()  { return false; }  // TODO: valueOf(100)
    static boolean largeIntegersAreShared()  { return false; }  // TODO: valueOf(200)

    static int sharedCounterAfter(int objects) { return 0; }  // TODO
    static int instanceFieldOfEach()           { return -1; } // TODO

    // "method area", "heap" or "stack".
    static String areaOf(String what) { return ""; }  // TODO

    public static void main(String[] args) {
        // TODO: predict all five comparisons, then run them
        // TODO: name the area for the static, the instance field, the literal and the new String
    }
}

class ThreadCost {
    static int maxPlatformThreads(int ceiling)
    static long stackBytesPerThread()
    static long megabytesFor(int threads)
    static int virtualThreadsIn(int count) throws Exception
    static boolean threadCostsBeforeItWorks()
}

import java.util.*;
import java.util.concurrent.*;

public class ThreadCost {

    // Start threads until the machine refuses, holding them ALIVE while you count.
    // Make them daemons and release them in a finally, or the tests will hang.
    static int maxPlatformThreads(int ceiling) { return 0; }  // TODO

    static long stackBytesPerThread() { return 0; }  // TODO: the usual default
    static long megabytesFor(int threads) { return 0; }  // TODO

    // Virtual threads instead. Return how many finished.
    static int virtualThreadsIn(int count) throws Exception { return 0; }  // TODO

    // Is the memory reserved before the thread does any work?
    static boolean threadCostsBeforeItWorks() { return false; }  // TODO

    public static void main(String[] args) throws Exception {
        // TODO: find the platform ceiling, then try -Xss256k and compare
        // TODO: work out what a thousand idle threads cost before doing anything
    }
}