> For the complete documentation index, see [llms.txt](https://www.pranaypourkar.co.in/the-programmers-guide/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://www.pranaypourkar.co.in/the-programmers-guide/java/java-basics/parallelism-and-concurrency/thread-fundamentals/thread-lifecycle-and-states.md).

# Thread Lifecycle & States

## About

Threads in Java go through several states during their lifecycle. These states are defined in the `Thread.State` enum and managed by the Java Virtual Machine (JVM). Below is a detailed breakdown of all possible states, transitions, and in-depth concepts related to thread lifecycle management.

## **Thread States**

A thread in Java can be in one of the following states at any given time.

<table data-header-hidden><thead><tr><th width="204"></th><th></th></tr></thead><tbody><tr><td><strong>State</strong></td><td><strong>Description</strong></td></tr><tr><td><strong>NEW</strong></td><td>Thread is created but not yet started.</td></tr><tr><td><strong>RUNNABLE</strong></td><td>Thread is ready to run and waiting for CPU time.</td></tr><tr><td><strong>BLOCKED</strong></td><td>Thread is waiting for a monitor lock (due to synchronization).</td></tr><tr><td><strong>WAITING</strong></td><td>Thread is waiting indefinitely for another thread's signal.</td></tr><tr><td><strong>TIMED_WAITING</strong></td><td>Thread is waiting for a specified time before resuming.</td></tr><tr><td><strong>TERMINATED</strong></td><td>Thread has completed execution or was stopped abnormally.</td></tr></tbody></table>

## **State Transitions & Lifecycle**

A Java thread transitions between states as follows:

### **1. New (Unstarted)**

* When a thread is created using `new Thread()`, it remains in the **NEW** state.
* The thread has not started yet and is simply an object in memory.

```java
Thread t = new Thread(() -> System.out.println("Thread running"));
System.out.println(t.getState()); // Output: NEW
```

### **2. Runnable (Ready to Run)**

* When `start()` is called, the thread moves to the **RUNNABLE** state.
* It is waiting for CPU time and may be scheduled for execution at any moment.

```java
t.start();
System.out.println(t.getState()); // Output: RUNNABLE
```

### **3. Blocked (Waiting for a Lock)**

* If a thread tries to enter a synchronized block but another thread holds the lock, it moves to the **BLOCKED** state.
* It remains blocked until the lock is released.

```java
public class SharedResource {
    synchronized void access() {
        System.out.println(Thread.currentThread().getName() + " is inside.");
        try { Thread.sleep(1000); } catch (InterruptedException ignored) {}
    }
}

SharedResource resource = new SharedResource();

Thread t1 = new Thread(() -> resource.access());
Thread t2 = new Thread(() -> resource.access());

t1.start();
t2.start();

Thread.sleep(100); // Allow t1 to acquire lock
System.out.println(t2.getState()); // Output: BLOCKED
```

### **4. Waiting (Indefinitely Waiting)**

* A thread enters the **WAITING** state when it calls `Object.wait()` or `Thread.join()` **without a timeout**.
* It remains in this state until another thread calls `notify()` or `notifyAll()`.

```java
public class WaitingDemo {
    synchronized void waitForSignal() throws InterruptedException {
        System.out.println("Waiting...");
        wait();  // Moves to WAITING state
        System.out.println("Resumed.");
    }
}

WaitingDemo obj = new WaitingDemo();
Thread t = new Thread(() -> {
    try { obj.waitForSignal(); } catch (InterruptedException ignored) {}
});
t.start();

Thread.sleep(100); // Allow thread to enter WAITING state
System.out.println(t.getState()); // Output: WAITING
```

### **5. Timed Waiting (Waiting for a Limited Time)**

* A thread enters **TIMED\_WAITING** when it calls:
  * `Thread.sleep()`
  * `join(timeout)`
  * `wait(timeout)`
  * `LockSupport.parkNanos()` or `parkUntil()`

```java
Thread t = new Thread(() -> {
    try { Thread.sleep(2000); } catch (InterruptedException ignored) {}
});
t.start();

Thread.sleep(100); // Allow thread to enter TIMED_WAITING
System.out.println(t.getState()); // Output: TIMED_WAITING
```

### **6. Terminated (Completed or Stopped)**

* When a thread finishes execution or is forcibly stopped, it moves to **TERMINATED** state.
* A thread in this state **cannot be restarted**.

```java
Thread t = new Thread(() -> System.out.println("Thread executing"));
t.start();

Thread.sleep(100);
System.out.println(t.getState()); // Output: TERMINATED
```

### **7. Interrupting a Thread**

* A thread can be interrupted while it's in **RUNNABLE**, **WAITING**, or **TIMED\_WAITING** states.
* If a thread is in **WAITING** or **TIMED\_WAITING**, it throws `InterruptedException`.

```java
Thread t = new Thread(() -> {
    try { Thread.sleep(5000); } catch (InterruptedException e) {
        System.out.println("Thread was interrupted.");
    }
});

t.start();
Thread.sleep(100);
t.interrupt(); // Interrupts the sleeping thread
```

## **Comparison Between Thread States**

<table data-header-hidden data-full-width="true"><thead><tr><th width="193"></th><th width="199"></th><th></th></tr></thead><tbody><tr><td><strong>State</strong></td><td><strong>Can Execute Code?</strong></td><td><strong>Moves To?</strong></td></tr><tr><td><strong>NEW</strong></td><td>No</td><td>RUNNABLE (on <code>start()</code>)</td></tr><tr><td><strong>RUNNABLE</strong></td><td>Yes</td><td>BLOCKED, WAITING, TIMED_WAITING, TERMINATED</td></tr><tr><td><strong>BLOCKED</strong></td><td>No</td><td>RUNNABLE (once lock is released)</td></tr><tr><td><strong>WAITING</strong></td><td>No</td><td>RUNNABLE (on <code>notify()</code>, <code>interrupt()</code>, or <code>join()</code> completion)</td></tr><tr><td><strong>TIMED_WAITING</strong></td><td>No</td><td>RUNNABLE (on timeout or <code>interrupt()</code>)</td></tr><tr><td><strong>TERMINATED</strong></td><td>No</td><td>(Cannot restart)</td></tr></tbody></table>

## **Best Practices for Thread Management**

* **Avoid blocking threads unnecessarily** → Prefer non-blocking APIs like `CompletableFuture`.
* **Use thread pools instead of manually creating threads** → `Executors.newFixedThreadPool(n)`.
* **Interrupt threads properly** → Always check `Thread.interrupted()` inside loops.
* **Synchronize shared resources properly** → Use `synchronized`, `ReentrantLock`, or atomic variables.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://www.pranaypourkar.co.in/the-programmers-guide/java/java-basics/parallelism-and-concurrency/thread-fundamentals/thread-lifecycle-and-states.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.