What a Thread Actually Is

A process is a running program with its own memory. A thread is one path of execution inside a process, sharing that memory with the others.

Inside the JVM the split is exactly the areas from Section 13.1:

Per thread                    Shared by all threads
──────────                    ─────────────────────
Stack                         Heap
  frames                        every object
  local variables               every array
  parameters                  Method area
PC register                     static fields
                                class definitions

That is the whole of concurrency in one picture. Locals are private for free, because no other thread can reach a frame that is not its own. Everything on the heap is reachable by all of them at once.

Making one:

Thread t = new Thread(() -> {
    System.out.println("running on " + Thread.currentThread().getName());
});
t.start();

The lambda is a Runnable, which has one abstract method, so it is a functional interface from Section 11.1. Nothing new.

And now the mistake everyone makes once:

new Thread(() -> System.out.println(Thread.currentThread().getName())).run();

main

run() is an ordinary method call. It runs on the thread you called it from and finishes before the next line. No thread was created. The code compiles, prints something sensible, and is entirely sequential.

start() is the one that asks the operating system for a thread. Only start() does that.

Proof that stacks are separate:

Runnable show = () -> {
    int local = 0;
    for (int i = 0; i < 3; i++) local++;
    System.out.println(Thread.currentThread().getName() + " local=" + local);
};
new Thread(show, "worker-1").start();
new Thread(show, "worker-2").start();

worker-1 local=3
worker-2 local=3

One Runnable, one local in the source, two values in memory. Each thread has its own frame, so each has its own copy, and neither can affect the other.

Change local to a field on a shared object and everything about that changes. That is Section 14.4.

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

1. What does a thread have of its own, and what does it share?

   Show the answer

   Its own: a stack, and a program counter. That means every local variable, every parameter and every frame belongs to one thread and no other thread can see them.

   Shared: the heap and the method area. Every object, every array and every static field is visible to every thread at once.

   Those are the areas from Section 13.1, split by who can reach them. A local is safe without any effort on your part, because reaching it is not possible. Anything on the heap is reachable by all of them, and that is where every problem in this phase comes from.

2. What is the difference between calling `run()` and calling `start()`?

   Show the answer

   start() asks the operating system for a new thread, which then calls run() on its own stack.

   run() is an ordinary method call. It runs on the thread you called it from, right now, and finishes before the next line. No thread is created at all.

   It compiles, it produces the right output, and it is completely sequential. Verified: calling run() directly on a new Thread prints main as the current thread name.

   This is the most common first mistake with threads, and nothing warns you. Your program works and gets none of the concurrency you wrote it for.

3. Why is starting a thread expensive, when starting a process is more expensive still?

   Show the answer

   A process gets its own memory space. Starting one means the operating system building a new address space, loading the program, and setting up its own heap. Nothing is shared, so two processes talk through pipes, sockets or files.

   A thread lives inside a process and shares its memory. Starting one is much cheaper than a process, and it is not free: the operating system is involved, and the thread reserves a stack, usually around 512 KB to 1 MB, before it does anything.

   A thousand idle threads is most of a gigabyte of stacks. That number is why the rest of this phase pools threads rather than making them.

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

4 exercises85 pointsabout 85 minutes

public class WhoIsRunning {
    public static void main(String[] args) {
        // TODO: print the name of every thread currently alive.
        //       Predict how many there will be before you run it.
        // TODO: mark which ones are daemons
        // TODO: look up what Reference Handler and Common-Cleaner are for.
        //       One of them connects straight back to Phase XIII.
        // TODO: start a thread of your own and print the list again
    }
}

public class RunOrStart {
    static void job(String label) {
        System.out.println(label + " on " + Thread.currentThread().getName());
        try { Thread.sleep(300); } catch (Exception e) { }
        System.out.println(label + " done");
    }

    public static void main(String[] args) {
        // TODO: three threads, started with run(). Time the whole thing.
        // TODO: three threads, started with start(). Time it again.
        // TODO: predict both timings BEFORE running
        // TODO: print the thread name inside each. What differs?
        // TODO: with start(), is the output order the same every run?
    }
}

public class Split {
    static int sharedField = 0;

    public static void main(String[] args) throws Exception {
        Runnable withLocal = () -> {
            int local = 0;
            for (int i = 0; i < 100_000; i++) local++;
            System.out.println(Thread.currentThread().getName() + " local=" + local);
        };

        // TODO: run withLocal on two threads. Predict both numbers first.
        // TODO: now write the same loop using sharedField instead of a local.
        //       Predict the total before running. Run it five times.
        // TODO: explain both results using stack and heap
        // TODO: which of the two could you have got wrong without any error appearing?
    }
}

public class TwoReasons {
    static void waiting()  { try { Thread.sleep(500); } catch (Exception e) { } }
    static long working()  { long x = 0; for (int i = 0; i < 200_000_000; i++) x += i; return x; }

    public static void main(String[] args) throws Exception {
        // TODO: run waiting() eight times, sequentially. Time it.
        // TODO: run it on eight threads. Time it. Predict first.
        // TODO: now do the same two experiments with working()
        // TODO: try 64 threads of each. Which one improves and which gets worse?
        // TODO: write one sentence on how you would size a pool for each kind of work
    }
}