Java Thread Lifecycle Interview Questions & Answers

Introduction

Every Java thread passes through a well-defined lifecycle from creation until termination.

Understanding thread states is essential because many production issues involve threads that are:

• Blocked
• Waiting
• Deadlocked
• Sleeping
• Running indefinitely

Senior Java interviews frequently include questions such as:

• Explain the Thread Lifecycle.
• What are the thread states?
• Difference between BLOCKED and WAITING.
• Difference between sleep() and wait().
• What does join() do?

Understanding thread states helps diagnose production issues using Thread Dumps and monitoring tools.

---

1. What is the Thread Lifecycle?

Answer

The Thread Lifecycle represents the different states a thread goes through during execution.

Complete Lifecycle

           NEW

            │

            ▼

       RUNNABLE

      ↙   │    ↘

BLOCKED WAITING TIMED_WAITING

      ↘   │    ↙

        RUNNABLE

            │

            ▼

      TERMINATED

Every Java thread transitions through one or more of these states.

---

2. What are the different thread states in Java?

Answer

Java defines six thread states.

State	Description
NEW	Thread created but not started
RUNNABLE	Ready to run or currently running
BLOCKED	Waiting to acquire a monitor lock
WAITING	Waiting indefinitely for another thread
TIMED_WAITING	Waiting for a specified time
TERMINATED	Execution completed

These states are represented by Thread.State.

---

3. What is the NEW state?

Answer

A thread is in the NEW state after it is created but before start() is called.

Example

Thread thread =

new Thread(task);

Lifecycle

Thread Created

↓

NEW

No operating system thread has started execution yet.

---

4. What is the RUNNABLE state?

Answer

A thread enters the RUNNABLE state after calling:

thread.start();

The thread is:

• Ready to execute
• Waiting for CPU scheduling
• Or currently executing

Illustration

start()

↓

RUNNABLE

↓

CPU Scheduler

↓

Execution

The JVM groups "ready" and "running" into the same RUNNABLE state.

---

5. What is the BLOCKED state?

Answer

A thread enters the BLOCKED state when waiting to acquire a monitor lock.

Example

synchronized(lock){

}

If another thread already owns the lock,

Thread

↓

Waiting for Lock

↓

BLOCKED

Once the lock becomes available, the thread returns to RUNNABLE.

---

6. What is the WAITING state?

Answer

WAITING means the thread waits indefinitely until another thread performs a specific action.

Common methods

wait()

join()

LockSupport.park()

Example

Thread A

↓

wait()

↓

WAITING

↓

notify()

↓

RUNNABLE

The thread remains waiting until it is notified or otherwise awakened.

---

7. What is TIMED_WAITING?

Answer

TIMED_WAITING means the thread waits for a specified amount of time.

Examples

Thread.sleep(5000);

wait(1000);

join(3000);

Lifecycle

sleep()

↓

TIMED_WAITING

↓

Timeout

↓

RUNNABLE

The JVM automatically moves the thread back to RUNNABLE when the timeout expires.

---

8. What is the TERMINATED state?

Answer

A thread enters TERMINATED after completing its run() method or after an uncaught exception ends execution.

Example

public void run() {

    System.out.println("Done");

}

Lifecycle

run()

↓

Execution Finished

↓

TERMINATED

A terminated thread cannot be restarted.

---

9. Can a terminated thread be started again?

Answer

No.

Example

thread.start();

thread.start();

Results in

IllegalThreadStateException

Each thread instance can be started only once.

---

10. What is the difference between BLOCKED and WAITING?

Answer

BLOCKED	WAITING
Waiting for a monitor lock	Waiting for another thread's action
Caused by synchronized blocks	Caused by wait(), join(), park()
JVM automatically acquires lock when available	Requires notification, completion, or unpark
Competes for a monitor	Does not compete for a monitor while waiting

This is a common senior interview question.

---

11. How do sleep(), wait(), and join() affect thread states?

Answer

sleep()

Thread.sleep(1000);

State

TIMED_WAITING

---

wait()

wait();

State

WAITING

---

join()

thread.join();

State

WAITING

or

TIMED_WAITING

if a timeout is specified.

---

12. Explain a production use case.

Answer

Scenario

A Spring Boot application processes orders asynchronously.

Request

↓

Worker Thread

↓

Database Lock

↓

BLOCKED

↓

Lock Acquired

↓

RUNNABLE

↓

API Call

↓

TIMED_WAITING

↓

Completed

↓

TERMINATED

During production troubleshooting, Thread Dumps reveal whether threads are:

• Running
• Waiting
• Blocked
• Deadlocked

This information is invaluable for diagnosing performance problems.

---

13. What are common mistakes related to the Thread Lifecycle?

Answer

Common mistakes include:

Calling start() twice.

Confusing RUNNABLE with actively running.

Thinking sleep() releases locks.

Confusing BLOCKED with WAITING.

Ignoring Thread Dumps during production debugging.

Understanding thread transitions simplifies troubleshooting.

---

14. What are the best practices?

Answer

Recommended practices

• Use thread pools instead of creating threads manually.
• Avoid unnecessary blocking.
• Keep synchronized sections short.
• Use wait() and notify() correctly.
• Prefer high-level concurrency utilities when possible.
• Monitor thread states using Thread Dumps.
• Avoid long-running blocking operations.
• Design threads to terminate gracefully.

---

15. What interview tips should you remember?

Answer

Interviewers commonly ask:

• Thread Lifecycle
• Thread states
• NEW
• RUNNABLE
• BLOCKED
• WAITING
• TIMED_WAITING
• TERMINATED
• sleep()
• wait()
• join()

Remember

• Every thread starts in the NEW state.
• start() moves a thread to RUNNABLE.
• BLOCKED means waiting for a monitor lock.
• WAITING means waiting indefinitely for another thread.
• TIMED_WAITING waits for a specified duration.
• TERMINATED means execution has finished.
• A thread cannot be restarted after termination.
• Thread Dumps are essential for production debugging.

---

Summary

The Java Thread Lifecycle defines how threads transition through various execution states from creation to termination. Understanding these states is critical for writing efficient multithreaded applications, diagnosing production issues, analyzing Thread Dumps, and answering advanced Java interview questions.

Key Takeaways

• Understand all six Java thread states.
• Learn how threads transition between states.
• Know the difference between BLOCKED and WAITING.
• Understand how sleep(), wait(), and join() affect thread state.
• Learn why terminated threads cannot be restarted.
• Use Thread Dumps to analyze thread behavior.
• Avoid common lifecycle mistakes.
• Follow enterprise multithreading best practices.
• Support interview answers with production examples.
• Build a strong foundation for Synchronization and Thread Communication.

---