Two Ways to Make One, and Six States

Implement Runnable. Almost always.

Java has single inheritance, from Section 7.1. Extending Thread spends it, and a class that extends Thread can never extend anything else for the rest of its life.

It is also the wrong shape. extends means is a. A report job is not a kind of thread. It is work, and a thread is the thing that runs work.

The practical reason is the one that decides it. A Runnable can be given to a Thread today and to an executor in Section 14.10 without changing a line. A subclass of Thread is tied to being a thread, and a thread can only be started once.

A thread moves through six states, and you can watch it.

Verified by asking a running program:

before start()      : NEW
busy loop           : RUNNABLE
Thread.sleep        : TIMED_WAITING
lock.wait()         : WAITING
waiting for a lock  : BLOCKED
after it finished   : TERMINATED

The three not-running states are three different problems.

BLOCKED means contention. Several threads want the same lock, and they are taking turns. It resolves on its own.

WAITING means a thread is expecting something. If the signal never comes, it waits forever, and a group of threads in WAITING all expecting each other is a deadlock.

TIMED_WAITING means it will come back by itself.

And you can be told when one dies:

worker.setUncaughtExceptionHandler((t, e) ->
    log.error("thread {} died: {}", t.getName(), e.getMessage(), e));

handler saw: boom / thread died
main is still alive : true

Set it before start(). Without one, the default prints the trace to the console and that is the whole notification you get.

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

1. Why is implementing `Runnable` almost always better than extending `Thread`?

   Show the answer

   Because extending spends the one superclass you have. Java allows single inheritance only, from Section 7.1, so a class that extends Thread can never extend anything else.

   It is also the wrong relationship. Your class is a piece of work, not a kind of thread. Extending says is a, and a payroll job is not a kind of thread.

   The practical reason is reuse. A Runnable can be handed to a Thread, to an executor, to a scheduled task. A subclass of Thread can only be one thread, once, because a thread that has finished cannot be started again.

2. Three of the six states mean the thread is not running. What is different about them?

   Show the answer

   BLOCKED means it is waiting to get into a synchronized block. It wants a lock somebody else is holding. It will run the moment that lock is released, and nobody has to tell it anything.

   WAITING means it called something with no time limit, like wait() or join(). It will not wake up on its own. Another thread has to call notify or finish.

   TIMED_WAITING is the same with a deadline, like Thread.sleep(1000). It wakes on its own when the time is up.

   The difference matters when a program has stopped. Threads sitting in BLOCKED are fighting over a lock. Threads in WAITING are expecting a signal that may never come, and that is what a deadlock looks like in a thread dump.

3. A thread throws an exception nobody catches. What happens to the program?

   Show the answer

   That thread dies. Its stack trace is printed. Everything else carries on as if nothing happened.

   The exception does not travel to whoever called start(), because that thread has long since moved on. Each thread has its own stack, so there is nowhere for it to unwind to.

   That makes a failed worker invisible. Your program keeps running with one fewer thread doing its job, and unless you are reading the console nothing tells you.

   setUncaughtExceptionHandler is how you find out. Verified: the handler is called with the thread and the exception, and main continues normally.

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

4 exercises95 pointsabout 100 minutes

public class Spent {
    static abstract class Job {
        abstract String name();
        void report() { System.out.println("job: " + name()); }
    }

    // TODO: write ReportJob extending Thread. Now also make it extend Job.
    //       Read the error.

    // TODO: write the same thing implementing Runnable, and extending Job as well

    public static void main(String[] args) throws Exception {
        // TODO: run both versions
        // TODO: hand the Runnable to a Thread, then hand the SAME object to a
        //       second Thread. Try the equivalent with your Thread subclass.
        // TODO: write the Runnable version as a lambda. Try that with Thread.
    }
}

public class SixStates {
    static final Object lock = new Object();

    public static void main(String[] args) throws Exception {
        // TODO: get a thread into each of the six states and print getState()
        //   NEW            easy
        //   RUNNABLE       a busy loop
        //   TIMED_WAITING  Thread.sleep
        //   WAITING        lock.wait(), or join on a long thread
        //   BLOCKED        one thread holds a lock while another wants it
        //   TERMINATED     let one finish
        // TODO: make the observing thread sleep briefly before each check. Why?
        // TODO: say what each of BLOCKED, WAITING and TIMED_WAITING means for a
        //       program that has stopped responding
    }
}

public class Quiet {
    public static void main(String[] args) throws Exception {
        // TODO: start a thread that throws. Wrap start() in a try/catch.
        //       Predict whether the catch runs.
        // TODO: confirm main keeps going afterwards
        // TODO: add setUncaughtExceptionHandler and try again
        // TODO: start five workers, have one of them throw, and show the program
        //       carries on with four. How would you have found out without the handler?
        // TODO: explain why the exception cannot reach main, using stacks
    }
}

import java.util.*;

public class Joining {
    public static void main(String[] args) throws Exception {
        List<String> results = Collections.synchronizedList(new ArrayList<>());

        // TODO: start four threads, each adding one result after a short sleep
        // TODO: print results WITHOUT joining. Run it five times.
        // TODO: now join all four first, and run it five times again
        // TODO: give the threads different sleep lengths. Does the missing count change?
        // TODO: what state is main in while it is inside join()?
    }
}