Multithreading Basics and Thread Life Cycle

A process is an independently running program with its own memory space — for example, your browser and your IDE are two separate processes, and one cannot directly read the other's memory. A thread is a lightweight sub-unit of a process; multiple threads within the same process share that process's memory (heap, static fields) but each thread keeps its own stack, program counter, and local variables. Multithreading is the ability to run several threads concurrently within a single process.

Java has supported multithreading since its first release through the java.lang.Thread class and the Runnable interface. Threads are useful because they let a program do more than one thing "at the same time" — for example, a server handling many client connections, or a UI staying responsive while a background task loads data — without needing multiple separate processes, which would be far more expensive to create and communicate between.

Why it matters

Any server handling many requests, or any application that stays responsive while it works, uses threads. Before you can reason about what a thread is doing — or why it appears stuck — you need the vocabulary of its states. A thread dump from a hung production system is simply a list of threads and the state each one is in.

Why Threads Instead of Processes

Creating a new process means the operating system allocates a fresh memory space and duplicates resources, which is comparatively slow and memory-heavy. Creating a new thread is much cheaper because it reuses the same process memory and just adds a new stack and execution path. Threads within one process can also communicate directly through shared variables, whereas processes typically need explicit inter-process communication (sockets, pipes, files) to exchange data.

The Thread Life Cycle

Every Java thread moves through a well-defined set of states, represented by the enum Thread.State. Understanding these states is essential for debugging concurrency issues, because tools like thread dumps report exactly these state names.

• New — the thread object has been created (new Thread(...)) but start() has not yet been called; no OS-level thread exists yet.
• Runnable — after start() is called, the thread is eligible to run; it may be actively executing on a CPU core or simply waiting its turn from the thread scheduler. Java does not distinguish "ready" from "running" as a separate state — both fall under RUNNABLE.
• Blocked — the thread is waiting to acquire an intrinsic lock (a synchronized block or method) that another thread currently holds.
• Waiting — the thread is waiting indefinitely for another thread to perform a specific action, typically via Object.wait() (with no timeout), Thread.join() (with no timeout), or LockSupport.park().
• Timed Waiting — like Waiting, but bounded by a timeout, as with Thread.sleep(ms), wait(ms), or join(ms).
• Terminated — the thread has finished executing its run() method, either normally or due to an uncaught exception. A terminated thread cannot be restarted.

Who Controls the Transitions

Moving from New to Runnable is always your explicit action — calling start(). Moving out of Runnable into Blocked, Waiting, or Timed Waiting happens automatically based on what the thread's code does (trying to enter a locked block, calling wait(), calling sleep()). The JVM thread scheduler — not your program — decides exactly when a Runnable thread actually gets CPU time, and that decision is not guaranteed to be fair or deterministic across runs.

Example

public class LifeCycleDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            try {
                Thread.sleep(200);
            } catch (InterruptedException ignored) {
            }
        });

        System.out.println("Before start(): " + worker.getState());   // NEW

        worker.start();
        System.out.println("Just after start(): " + worker.getState()); // RUNNABLE

        Thread.sleep(50); // give the worker time to reach sleep()
        System.out.println("While worker sleeps: " + worker.getState()); // TIMED_WAITING

        worker.join();
        System.out.println("After join(): " + worker.getState());     // TERMINATED
    }
}

Before start(): NEW
Just after start(): RUNNABLE
While worker sleeps: TIMED_WAITING
After join(): TERMINATED

Exercise

Print the state of a thread at two moments: after it has been created but not started, and after it has finished. Use join() to wait for it to finish.

Expected output: NEW then TERMINATED

public class ThreadStates {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> { });

        // TODO: print the state before starting the thread
        // TODO: start it, wait for it to finish, then print the state again
    }
}

public class ThreadStates {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> { });

        System.out.println(worker.getState()); // NEW
        worker.start();
        worker.join();
        System.out.println(worker.getState()); // TERMINATED
    }
}

Quick quiz

Interview questions