{"title":"Thread Lifecycle","description":null,"content":"When you create a thread, it doesn't start running immediately. When it's running, it might pause to wait for a lock or sleep for a duration. When it finishes, it doesn't disappear instantly.\n\nA thread goes through several **states** during its lifetime. Understanding these states helps you write correct concurrent code, debug threading issues, and answer interview questions about multithreading.\n\nIn this article, we'll explore:\n\n- The states a thread can be in\n- How threads transition between states\n- What triggers each transition\n- How to observe thread states\n- Common patterns and pitfalls\n\n---\n\n# 1. Thread States Overview\n\nA thread can be in one of the following states:\n\n\n| ##### State | ##### Description |\n| --- | --- |\n| **New** | Thread object created, but `start()` not yet called |\n| **Runnable** | Ready to run or currently running |\n| **Blocked** | Waiting to acquire a lock |\n| **Waiting** | Waiting indefinitely for another thread |\n| **Timed Waiting** | Waiting for a specified time |\n| **Terminated** | Execution completed |\n\n\n\n```mermaid\nstateDiagram-v2\n [*] --> New: Thread created\n New --> Runnable: start()\n Runnable --> Blocked: Waiting for lock\n Runnable --> Waiting: wait(), join()\n Runnable --> TimedWaiting: sleep(), wait(timeout)\n Blocked --> Runnable: Lock acquired\n Waiting --> Runnable: notify(), notifyAll()\n TimedWaiting --> Runnable: Timeout or notify\n Runnable --> Terminated: run() completes\n Terminated --> [*]\n\n note right of Runnable\n Thread is either running\n or ready to run\n end note\n```\n\n\n\n> **INFO**\n>\n> The key insight: A thread in the \"Runnable\" state isn't necessarily running. It means the thread is eligible to run, and the OS scheduler decides when it actually gets CPU time.\n\n\n---\n\n# 2. State 1: New\n\nA thread is in the **New** state when you create a Thread object but haven't called `start()` yet.\n\n\n```java\nThread thread = new Thread(() -> {\n System.out.println(\"Running\");\n});\n\n// Thread is in NEW state here\nSystem.out.println(thread.getState()); // Output: NEW\n```\n\n\nIn this state:\n\n- The thread object exists in memory\n- No system resources are allocated for execution\n- The thread has not begun executing\n\n\n```mermaid\nflowchart LR\n Create[\"new Thread()\"]\n New[\"NEW State\"]\n Create --> New\n\n style Create fill:#00ceff,stroke:#000,color:#000\n style New fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nA thread can only be started once. Calling `start()` on an already-started thread throws `IllegalThreadStateException`.\n\n---\n\n# 3. State 2: Runnable\n\nWhen you call `start()`, the thread moves to the **Runnable** state. This state actually encompasses two sub-states:\n\n1. **Ready**: Waiting for CPU time\n2. **Running**: Currently executing on a CPU core\n\n\n```mermaid\nflowchart TB\n subgraph Runnable[\"RUNNABLE State\"]\n Ready[\"Ready
(in run queue)\"]\n Running[\"Running
(on CPU)\"]\n Ready <-->|\"OS Scheduler\"| Running\n end\n\n New[\"NEW\"] -->|\"start()\"| Ready\n\n style Runnable fill:#69db7c,stroke:#000,color:#000\n style Ready fill:#38d9a9,stroke:#000,color:#000\n style Running fill:#00ceff,stroke:#000,color:#000\n style New fill:#ffa94d,stroke:#000,color:#000\n```\n\n\nThe OS scheduler constantly switches between threads, giving each a slice of CPU time. Your code cannot distinguish between \"ready\" and \"running\" because this is managed by the operating system.\n\n\n```java\nThread thread = new Thread(() -> {\n // Thread is RUNNABLE while this code executes\n for (int i = 0; i < 1000000; i++) {\n // CPU-bound work\n }\n});\n\nthread.start();\nSystem.out.println(thread.getState()); // Output: RUNNABLE\n```\n\n\n---\n\n# 4. State 3: Blocked\n\nA thread enters the **Blocked** state when it tries to acquire a lock (monitor) that another thread holds.\n\n\n```java\nObject lock = new Object();\n\nThread thread1 = new Thread(() -> {\n synchronized (lock) {\n // Thread 1 holds the lock\n try {\n Thread.sleep(5000); // Hold lock for 5 seconds\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n});\n\nThread thread2 = new Thread(() -> {\n synchronized (lock) {\n // Thread 2 wants the same lock\n System.out.println(\"Thread 2 acquired lock\");\n }\n});\n\nthread1.start();\nThread.sleep(100); // Let thread1 acquire lock first\nthread2.start();\nThread.sleep(100);\n\nSystem.out.println(thread2.getState()); // Output: BLOCKED\n```\n\n\n\n```mermaid\nsequenceDiagram\n participant T1 as Thread 1\n participant Lock as Lock (Monitor)\n participant T2 as Thread 2\n\n T1->>Lock: acquire lock\n Lock-->>T1: lock granted\n Note over T1: RUNNABLE (holds lock)\n\n T2->>Lock: try to acquire lock\n Note over T2: BLOCKED (waiting for lock)\n\n T1->>Lock: release lock\n Lock-->>T2: lock granted\n Note over T2: RUNNABLE (holds lock)\n```\n\n\nA thread exits the Blocked state only when:\n\n- The lock becomes available\n- The thread successfully acquires it\n\nYou cannot interrupt a thread that is blocked waiting for a lock. It will wait until the lock is released.\n\n---\n\n# 5. State 4: Waiting\n\nA thread enters the **Waiting** state when it waits indefinitely for another thread to perform an action. This happens when calling:\n\n- `Object.wait()` (without timeout)\n- `Thread.join()` (without timeout)\n- `LockSupport.park()`\n\n\n```java\nObject lock = new Object();\n\nThread waiter = new Thread(() -> {\n synchronized (lock) {\n try {\n lock.wait(); // Wait indefinitely\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n});\n\nwaiter.start();\nThread.sleep(100);\nSystem.out.println(waiter.getState()); // Output: WAITING\n```\n\n\n\n```mermaid\nflowchart LR\n subgraph WaitingState[\"WAITING State\"]\n W1[\"wait()\"]\n W2[\"join()\"]\n W3[\"park()\"]\n end\n\n Runnable[\"RUNNABLE\"]\n\n Runnable -->|\"wait()\"| W1\n Runnable -->|\"join()\"| W2\n Runnable -->|\"park()\"| W3\n\n W1 -->|\"notify() / notifyAll()\"| Runnable\n W2 -->|\"Target thread terminates\"| Runnable\n W3 -->|\"unpark()\"| Runnable\n\n style Runnable fill:#69db7c,stroke:#000,color:#000\n style WaitingState fill:#9775fa,stroke:#000,color:#000\n style W1 fill:#38d9a9,stroke:#000,color:#000\n style W2 fill:#38d9a9,stroke:#000,color:#000\n style W3 fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n### wait() and notify()\n\nThe `wait()` method releases the lock and waits until another thread calls `notify()` or `notifyAll()` on the same object.\n\n\n```java\nObject lock = new Object();\n\nThread producer = new Thread(() -> {\n synchronized (lock) {\n System.out.println(\"Producing...\");\n lock.notify(); // Wake up waiting thread\n }\n});\n\nThread consumer = new Thread(() -> {\n synchronized (lock) {\n try {\n lock.wait(); // Release lock and wait\n System.out.println(\"Consumed!\");\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n});\n\nconsumer.start();\nThread.sleep(100); // Let consumer start waiting\nproducer.start();\n```\n\n\n### join()\n\nThe `join()` method makes the current thread wait until the target thread terminates.\n\n\n```java\nThread worker = new Thread(() -> {\n // Do some work\n System.out.println(\"Worker finished\");\n});\n\nworker.start();\nworker.join(); // Current thread enters WAITING state\nSystem.out.println(\"Main continues after worker\");\n```\n\n\n---\n\n# 6. State 5: Timed Waiting\n\nA thread enters the **Timed Waiting** state when it waits for a specified amount of time. This happens when calling:\n\n- `Thread.sleep(millis)`\n- `Object.wait(timeout)`\n- `Thread.join(timeout)`\n- `LockSupport.parkNanos(nanos)`\n- `LockSupport.parkUntil(deadline)`\n\n\n```java\nThread sleeper = new Thread(() -> {\n try {\n Thread.sleep(10000); // Sleep for 10 seconds\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n});\n\nsleeper.start();\nThread.sleep(100);\nSystem.out.println(sleeper.getState()); // Output: TIMED_WAITING\n```\n\n\n\n```mermaid\nflowchart TB\n Runnable[\"RUNNABLE\"]\n\n subgraph TimedWaiting[\"TIMED_WAITING State\"]\n Sleep[\"sleep(ms)\"]\n WaitT[\"wait(timeout)\"]\n JoinT[\"join(timeout)\"]\n end\n\n Runnable -->|\"sleep(ms)\"| Sleep\n Runnable -->|\"wait(timeout)\"| WaitT\n Runnable -->|\"join(timeout)\"| JoinT\n\n Sleep -->|\"Time elapsed or
interrupted\"| Runnable\n WaitT -->|\"Time elapsed,
notify, or interrupted\"| Runnable\n JoinT -->|\"Time elapsed or
thread terminates\"| Runnable\n\n style Runnable fill:#69db7c,stroke:#000,color:#000\n style TimedWaiting fill:#ffa94d,stroke:#000,color:#000\n style Sleep fill:#38d9a9,stroke:#000,color:#000\n style WaitT fill:#38d9a9,stroke:#000,color:#000\n style JoinT fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n### Difference: Waiting vs Timed Waiting\n\n\n| ##### Aspect | ##### Waiting | ##### Timed Waiting |\n| --- | --- | --- |\n| Duration | Indefinite | Specified timeout |\n| Exit condition | Explicit signal required | Timeout OR signal |\n| Risk | Can wait forever if not notified | Will eventually resume |\n| Use case | Event-driven waiting | Polling, timeouts |\n\n\n---\n\n# 7. State 6: Terminated\n\nA thread enters the **Terminated** state when its `run()` method completes, either normally or due to an exception.\n\n\n```java\nThread thread = new Thread(() -> {\n System.out.println(\"Starting\");\n // Work completes\n System.out.println(\"Done\");\n});\n\nthread.start();\nthread.join(); // Wait for completion\nSystem.out.println(thread.getState()); // Output: TERMINATED\n```\n\n\nA thread can also terminate due to an uncaught exception:\n\n\n```java\nThread thread = new Thread(() -> {\n throw new RuntimeException(\"Oops!\");\n});\n\nthread.setUncaughtExceptionHandler((t, e) -> {\n System.out.println(\"Thread \" + t.getName() + \" threw: \" + e.getMessage());\n});\n\nthread.start();\nthread.join();\nSystem.out.println(thread.getState()); // Output: TERMINATED\n```\n\n\n\n```mermaid\nflowchart TB\n Runnable[\"RUNNABLE\"]\n\n subgraph Termination[\"Termination Causes\"]\n Normal[\"run() completes
normally\"]\n Exception[\"Uncaught exception\"]\n Stop[\"Thread.stop()
(deprecated)\"]\n end\n\n Terminated[\"TERMINATED\"]\n\n Runnable --> Normal\n Runnable --> Exception\n Runnable --> Stop\n\n Normal --> Terminated\n Exception --> Terminated\n Stop --> Terminated\n\n style Runnable fill:#69db7c,stroke:#000,color:#000\n style Termination fill:#ffa94d,stroke:#000,color:#000\n style Terminated fill:#ff8787,stroke:#000,color:#000\n style Normal fill:#38d9a9,stroke:#000,color:#000\n style Exception fill:#38d9a9,stroke:#000,color:#000\n style Stop fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nOnce a thread is terminated:\n\n- It cannot be restarted\n- Calling `start()` throws `IllegalThreadStateException`\n- The Thread object can still be referenced (to get final state, name, etc.)\n- Resources are eventually garbage collected\n\n---\n\n# 8. Complete State Transition Diagram\n\nHere's the complete picture of all state transitions:\n\n\n```mermaid\nstateDiagram-v2\n direction TB\n\n [*] --> NEW: new Thread()\n\n NEW --> RUNNABLE: start()\n\n RUNNABLE --> BLOCKED: synchronized
(lock unavailable)\n BLOCKED --> RUNNABLE: Lock acquired\n\n RUNNABLE --> WAITING: wait()
join()
park()\n WAITING --> RUNNABLE: notify()
notifyAll()
unpark()
thread terminates\n\n RUNNABLE --> TIMED_WAITING: sleep(ms)
wait(ms)
join(ms)
parkNanos()\n TIMED_WAITING --> RUNNABLE: Timeout expires
or notified
or interrupted\n\n RUNNABLE --> TERMINATED: run() exits\n WAITING --> TERMINATED: Exception\n TIMED_WAITING --> TERMINATED: Exception\n\n TERMINATED --> [*]\n```\n\n\n### Transition Summary Table\n\n\n| ##### From | ##### To | ##### Trigger |\n| --- | --- | --- |\n| NEW | RUNNABLE | `start()` |\n| RUNNABLE | BLOCKED | Enter `synchronized` block, lock unavailable |\n| BLOCKED | RUNNABLE | Lock becomes available |\n| RUNNABLE | WAITING | `wait()`, `join()`, `park()` |\n| WAITING | RUNNABLE | `notify()`, `notifyAll()`, thread terminates, `unpark()` |\n| RUNNABLE | TIMED_WAITING | `sleep(ms)`, `wait(ms)`, `join(ms)` |\n| TIMED_WAITING | RUNNABLE | Timeout, `notify()`, `interrupt()` |\n| RUNNABLE | TERMINATED | `run()` completes or throws exception |\n\n\n---\n\n## 9. Observing Thread States\n\nYou can check a thread's current state using `getState()`:\n\n\n```java\npublic class ThreadStateDemo {\n public static void main(String[] args) throws InterruptedException {\n Object lock = new Object();\n\n Thread thread = new Thread(() -> {\n synchronized (lock) {\n try {\n lock.wait();\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n });\n\n System.out.println(\"After creation: \" + thread.getState()); // NEW\n\n thread.start();\n Thread.sleep(100);\n System.out.println(\"After start and wait: \" + thread.getState()); // WAITING\n\n synchronized (lock) {\n lock.notify();\n }\n Thread.sleep(100);\n System.out.println(\"After notify: \" + thread.getState()); // TERMINATED\n }\n}\n```\n\n\nOutput:\n\n\n```shell\nAfter creation: NEW\nAfter start and wait: WAITING\nAfter notify: TERMINATED\n```\n\n\n---\n\n# 10. Interrupting Threads\n\nInterruption is the standard way to signal a thread that it should stop. It affects threads in WAITING and TIMED_WAITING states:\n\n\n```java\nThread sleeper = new Thread(() -> {\n try {\n Thread.sleep(60000); // Sleep for 1 minute\n } catch (InterruptedException e) {\n System.out.println(\"Sleep interrupted!\");\n Thread.currentThread().interrupt(); // Preserve interrupt status\n }\n});\n\nsleeper.start();\nThread.sleep(100);\n\nSystem.out.println(\"State: \" + sleeper.getState()); // TIMED_WAITING\n\nsleeper.interrupt(); // Interrupt the sleeping thread\n\nThread.sleep(100);\nSystem.out.println(\"State: \" + sleeper.getState()); // TERMINATED\n```\n\n\n\n```mermaid\nflowchart LR\n TW[\"TIMED_WAITING
(sleeping)\"]\n Int[\"interrupt()\"]\n Ex[\"InterruptedException\"]\n Run[\"RUNNABLE
(handling exception)\"]\n\n TW -->|\"interrupt()\"| Int\n Int --> Ex\n Ex --> Run\n\n style TW fill:#ffa94d,stroke:#000,color:#000\n style Int fill:#ff8787,stroke:#000,color:#000\n style Ex fill:#9775fa,stroke:#000,color:#000\n style Run fill:#69db7c,stroke:#000,color:#000\n```\n\n\n### Interrupt Behavior by State\n\n\n| ##### State | ##### Effect of interrupt() |\n| --- | --- |\n| NEW | Sets interrupt flag (no immediate effect) |\n| RUNNABLE | Sets interrupt flag |\n| BLOCKED | Sets interrupt flag (does NOT unblock) |\n| WAITING | Throws `InterruptedException`, clears flag |\n| TIMED_WAITING | Throws `InterruptedException`, clears flag |\n| TERMINATED | No effect |\n\n\n---\n\n# 11. Common Patterns\n\n### Pattern 1: Graceful Shutdown\n\nUse the interrupt flag to stop a thread gracefully:\n\n\n```java\nThread worker = new Thread(() -> {\n while (!Thread.currentThread().isInterrupted()) {\n // Do work\n try {\n Thread.sleep(100);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt(); // Restore flag\n break;\n }\n }\n System.out.println(\"Worker stopped gracefully\");\n});\n\nworker.start();\nThread.sleep(500);\nworker.interrupt(); // Signal to stop\n```\n\n\n### Pattern 2: Waiting with Timeout\n\nAvoid waiting forever by using timeouts:\n\n\n```java\nsynchronized (lock) {\n long deadline = System.currentTimeMillis() + 5000; // 5 second timeout\n\n while (!conditionMet()) {\n long remaining = deadline - System.currentTimeMillis();\n if (remaining <= 0) {\n throw new TimeoutException(\"Condition not met within timeout\");\n }\n lock.wait(remaining);\n }\n}\n```\n\n\n### Pattern 3: Join with Timeout\n\nDon't wait forever for another thread:\n\n\n```java\nThread worker = new Thread(() -> {\n // Potentially long-running task\n});\n\nworker.start();\nworker.join(5000); // Wait at most 5 seconds\n\nif (worker.isAlive()) {\n System.out.println(\"Worker still running, proceeding without result\");\n worker.interrupt();\n}\n```\n\n\n---\n\n# 12. Common Pitfalls\n\n### Pitfall 1: Calling run() Instead of start()\n\n\n```java\n// Wrong: Executes in current thread, no new thread created\nThread t = new Thread(() -> System.out.println(\"Hello\"));\nt.run(); // Thread stays in NEW state!\n\n// Correct: Creates new thread\nt.start();\n```\n\n\n### Pitfall 2: Busy Waiting\n\n\n```java\n// Bad: Wastes CPU cycles\nwhile (!ready) {\n // Spin, checking constantly\n}\n\n// Good: Use proper waiting\nsynchronized (lock) {\n while (!ready) {\n lock.wait();\n }\n}\n```\n\n\n### Pitfall 3: Ignoring InterruptedException\n\n\n```java\n// Bad: Swallows interrupt\ntry {\n Thread.sleep(1000);\n} catch (InterruptedException e) {\n // Ignored\n}\n\n// Good: Restore interrupt status\ntry {\n Thread.sleep(1000);\n} catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n}\n```\n\n\n### Pitfall 4: Not Using Loops with wait()\n\n\n```java\n// Bad: Spurious wakeups can cause issues\nsynchronized (lock) {\n if (!conditionMet()) {\n lock.wait();\n }\n // Assumes condition is now met (might not be!)\n}\n\n// Good: Always use while loop\nsynchronized (lock) {\n while (!conditionMet()) {\n lock.wait();\n }\n // Condition is guaranteed to be met\n}\n```\n\n\n---\n\n# 13. Summary\n\nA thread moves through these states during its lifecycle:\n\n\n```mermaid\nflowchart LR\n NEW[\"NEW\"]\n RUN[\"RUNNABLE\"]\n BLK[\"BLOCKED\"]\n WAIT[\"WAITING\"]\n TW[\"TIMED_WAITING\"]\n TERM[\"TERMINATED\"]\n\n NEW -->|\"start()\"| RUN\n RUN -->|\"synchronized\"| BLK\n BLK -->|\"lock acquired\"| RUN\n RUN -->|\"wait()/join()\"| WAIT\n WAIT -->|\"notify()\"| RUN\n RUN -->|\"sleep()\"| TW\n TW -->|\"timeout\"| RUN\n RUN -->|\"run() exits\"| TERM\n\n style NEW fill:#00ceff,stroke:#000,color:#000\n style RUN fill:#69db7c,stroke:#000,color:#000\n style BLK fill:#ff8787,stroke:#000,color:#000\n style WAIT fill:#9775fa,stroke:#000,color:#000\n style TW fill:#ffa94d,stroke:#000,color:#000\n style TERM fill:#38d9a9,stroke:#000,color:#000\n```\n\n\n**Key Takeaways:**\n\n1. **NEW**: Created but not started\n2. **RUNNABLE**: Eligible to run (ready or running)\n3. **BLOCKED**: Waiting for a monitor lock\n4. **WAITING**: Waiting indefinitely for another thread\n5. **TIMED_WAITING**: Waiting with a timeout\n6. **TERMINATED**: Execution completed\n\n**Best Practices:**\n\n- Always use `start()`, never `run()` directly\n- Use `while` loops with `wait()` to handle spurious wakeups\n- Always restore interrupt status after catching `InterruptedException`\n- Prefer timed waits over indefinite waits\n- Use `getState()` for debugging, not for control flow\n\nUnderstanding thread states helps you debug concurrency issues, reason about thread behavior, and write correct multithreaded code.","pageType":"lld-interviews"}

Thread Lifecycle

Ashish Pratap Singh

Get Premium