Thread States & Lifecycle

## What a thread is A **thread** is an independent path of execution within a process: it has its own call stack and program counter but shares heap memory with other threads in the same JVM. In Java a thread is represented by a `java.lang.Thread` object. ## Why states exist A thread does not run continuously from birth to death. It is created, may run, may pause to wait for something (a lock, a timeout, a signal from another thread), and eventually finishes. To make this observable, Java defines an enum `Thread.State` with **exactly six** values. You query it with `thread.getState()`. This is a *diagnostic* view — it reflects what the thread is doing at the instant you ask. ## The six states, defined from scratch 1. **NEW** — The `Thread` object has been constructed (e.g. `new Thread(r)`) but `start()` has not been called yet. No OS-level thread exists; nothing is executing. 2. **RUNNABLE** — `start()` has been called. The thread is either actually running on a CPU core *or* sitting in the OS run queue waiting for a core. **Java deliberately merges 'running' and 'ready-to-run' into one state**, because from the JVM's point of view the OS scheduler owns that distinction. Importantly, a thread blocked on I/O (e.g. a socket read) is *still* RUNNABLE in Java's model — Java has no separate I/O-wait state. 3. **BLOCKED** — The thread is trying to enter a `synchronized` block or method but another thread holds that object's **monitor lock**. A monitor is the intrinsic lock every Java object carries. The thread parks here until the lock is released and it wins it. BLOCKED is *specifically* about monitor-lock contention. 4. **WAITING** — The thread is waiting **indefinitely** for an explicit action by another thread, with no timeout. You reach WAITING by calling `Object.wait()` (no args), `Thread.join()` (no args), or `LockSupport.park()`. It leaves WAITING only when another thread does the matching thing: `notify()`/`notifyAll()`, the joined thread terminating, or `unpark()`. 5. **TIMED_WAITING** — Same idea as WAITING, but bounded by a **timeout**. You reach it via `Thread.sleep(ms)`, `Object.wait(ms)`, `Thread.join(ms)`, `LockSupport.parkNanos`, or `parkUntil`. The thread leaves when it's signalled *or* when the deadline expires — whichever comes first. 6. **TERMINATED** — The thread's `run()` method has returned normally or propagated an exception. The thread is dead; it cannot be restarted (calling `start()` again throws `IllegalThreadStateException`). ## The key distinctions interviewers probe - **BLOCKED vs WAITING**: BLOCKED is *involuntary* contention for a monitor lock to enter `synchronized`. WAITING is *voluntary* — the thread called `wait()`/`join()`/`park()` and gave up the CPU until told otherwise. (Subtle: a thread that returns from `wait()` must *re-acquire* the monitor, so it can briefly pass through BLOCKED before becoming RUNNABLE.) - **WAITING vs TIMED_WAITING**: the only difference is whether a timeout was supplied. - **RUNNABLE is broad**: includes running, scheduler-ready, and blocked-on-I/O. ## How to observe it `Thread.getState()` returns the enum. Tools like `jstack` and thread dumps print these states, which is how you diagnose deadlocks (threads stuck in BLOCKED) or stuck waits (threads in WAITING). ## What NOT to do Never branch program logic on `getState()` — the value can change the instant after you read it (it is inherently racy). Use proper synchronization primitives instead.