Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Thread Life Cycle states in Java — NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED, state transitions, and how to observe thread states programmatically.
The Six Thread States
Every thread in Java exists in one of six states defined in Thread.State enum:
┌─────────────────────────────────────────────────────────────────────┐
│ THREAD LIFE CYCLE │
│ │
│ ┌─────┐ start() ┌──────────┐ │
│ │ NEW │ ─────────────→ │ RUNNABLE │←──────────────────┐ │
│ └─────┘ └────┬─────┘ │ │
│ │ │ │
│ ┌────────────────┼────────────────┐ │ │
│ │ │ │ │ │
│ ▼ ▼ ▼ │ │
│ ┌─────────────┐ ┌────────────┐ ┌──────────────┐ │ │
│ │ BLOCKED │ │ WAITING │ │TIMED_WAITING │ │ │
│ │ │ │ │ │ │ │ │
│ │ Waiting for │ │ wait() │ │ sleep(ms) │ │ │
│ │ monitor │ │ join() │ │ wait(ms) │ │ │
│ │ lock │ │ park() │ │ join(ms) │ │ │
│ └──────┬──────┘ └─────┬──────┘ └──────┬───────┘ │ │
│ │ │ │ │ │
│ │ Lock acquired │ notify() │ Timeout │ │
│ └─────────────────┴──────────────────┴─────────┘ │
│ │
│ run() completes │
│ │ │
│ ▼ │
│ ┌────────────┐ │
│ │ TERMINATED │ │
│ └────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
State Descriptions
| State | Description | How to Enter | How to Exit |
|---|---|---|---|
| NEW | Thread created but not started | new Thread() | start() |
| RUNNABLE | Ready to run or currently running | start(), lock acquired, notify | Completes, blocks, waits |
| BLOCKED | Waiting to acquire a monitor lock | Entering synchronized block | Lock becomes available |
| WAITING | Waiting indefinitely for another thread | wait(), join(), park() | notify(), notifyAll(), thread ends |
| TIMED_WAITING | Waiting for a specified time | sleep(ms), wait(ms), join(ms) | Timeout expires or notification |
| TERMINATED | Thread has completed execution | run() returns or exception | Cannot exit (final state) |
Observing All States
java example
public class ThreadStatesDemo {
private static final Object lock = new Object();
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Thread Life Cycle Demo ===\n");
// 1. NEW state
Thread thread = new Thread(() -> {
// Will show RUNNABLE, WAITING, TIMED_WAITING, BLOCKED
try {
Thread.sleep(100); // TIMED_WAITING
synchronized (lock) {
lock.wait(); // WAITING
}
} catch (InterruptedException e) {}
}, "TestThread");
System.out.println("After creation: " + thread.getState()); // NEW
// 2. RUNNABLE state
thread.start();
System.out.println("After start(): " + thread.getState()); // RUNNABLE
// 3. TIMED_WAITING state
Thread.sleep(50);
System.out.println("During sleep: " + thread.getState()); // TIMED_WAITING
// 4. WAITING state
Thread.sleep(200);
System.out.println("During wait(): " + thread.getState()); // WAITING
// Notify to continue
synchronized (lock) {
lock.notify();
}
// 5. TERMINATED state
thread.join();
System.out.println("After finish: " + thread.getState()); // TERMINATED
// Demonstrate BLOCKED
System.out.println("\n--- BLOCKED State Demo ---");
demonstrateBlocked();
}
static void demonstrateBlocked() throws InterruptedException {
Object resource = new Object();
// Thread 1 holds the lock
Thread holder = new Thread(() -> {
synchronized (resource) {
try { Thread.sleep(2000); } catch (InterruptedException e) {}
}
}, "LockHolder");
// Thread 2 tries to acquire same lock
Thread waiter = new Thread(() -> {
synchronized (resource) { // Will be BLOCKED here
System.out.println(" Waiter got the lock!");
}
}, "LockWaiter");
holder.start();
Thread.sleep(100);
waiter.start();
Thread.sleep(100);
System.out.println("Waiter state: " + waiter.getState()); // BLOCKED
holder.join();
waiter.join();
}
}Output:
| After creation | NEW |
| After start() | RUNNABLE |
| During sleep | TIMED_WAITING |
| During wait() | WAITING |
| After finish | TERMINATED |
| Waiter state | BLOCKED |
State Transitions in Detail
NEW → RUNNABLE (start())
java example
Thread t = new Thread(() -> {}); // State: NEW
t.start(); // State: RUNNABLE
// Note: RUNNABLE means ready to run OR currently running
// The OS scheduler decides when it actually gets CPU timeRUNNABLE → TIMED_WAITING (sleep, wait with timeout, join with timeout)
java example
Thread.sleep(1000); // TIMED_WAITING for 1 second
someObject.wait(5000); // TIMED_WAITING for up to 5 seconds
anotherThread.join(3000); // TIMED_WAITING for up to 3 secondsRUNNABLE → WAITING (wait, join without timeout)
java example
synchronized (obj) {
obj.wait(); // WAITING until notify() called
}
anotherThread.join(); // WAITING until anotherThread finishes
LockSupport.park(); // WAITING until unparkedRUNNABLE → BLOCKED (trying to enter synchronized)
java example
synchronized (alreadyLockedObject) {
// Thread is BLOCKED until lock is released by other thread
}Complete State Tracking Example
Example
public class StateTracker {
static Thread trackedThread;
static volatile boolean stopTracking = false;
public static void main(String[] args) throws InterruptedException {
System.out.println("=== State Tracker ===\n");
Object lock = new Object();
trackedThread = new Thread(() -> {
try {
// Phase 1: Running (compute)
long sum = 0;
for (int i = 0; i < 10_000_000; i++) sum += i;
// Phase 2: Sleeping
Thread.sleep(500);
// Phase 3: Waiting
synchronized (lock) {
lock.wait(800);
}
// Phase 4: More computation
for (int i = 0; i < 5_000_000; i++) sum += i;
} catch (InterruptedException e) {}
}, "Tracked");
// Tracker thread
Thread tracker = new Thread(() -> {
Thread.State lastState = null;
while (!stopTracking) {
Thread.State currentState = trackedThread.getState();
if (currentState != lastState) {
long time = System.currentTimeMillis() % 10000;
System.out.printf(" [%04d ms] State changed: %s → %s%n",
time, lastState, currentState);
lastState = currentState;
}
try { Thread.sleep(10); } catch (InterruptedException e) { break; }
}
}, "Tracker");
tracker.start();
Thread.sleep(50);
trackedThread.start();
trackedThread.join();
stopTracking = true;
tracker.join();
System.out.println("\n Final state: " + trackedThread.getState());
}
}
Output (approximate):
| [0250 ms] State changed: null | NEW |
| [0260 ms] State changed: NEW | RUNNABLE |
| [0285 ms] State changed: RUNNABLE | TIMED_WAITING |
| [0790 ms] State changed: TIMED_WAITING | RUNNABLE |
| [0792 ms] State changed: RUNNABLE | TIMED_WAITING |
| [1595 ms] State changed: TIMED_WAITING | RUNNABLE |
| [1610 ms] State changed: RUNNABLE | TERMINATED |
| Final state | TERMINATED |
Real-World Analogy: Thread States as a Restaurant Order
| NEW | Order placed (but kitchen hasn't started) |
| RUNNABLE | Chef is cooking your meal |
| BLOCKED | Chef needs the oven but someone else is using it |
| WAITING | Chef paused, waiting for ingredient delivery (no ETA) |
| TIMED_WAITING | Chef set a timer for 10 minutes (cooking) |
| TERMINATED | Meal is served and complete |
Checking Thread State Programmatically
java example
public class ThreadStateChecker {
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Thread State Enum Values ===\n");
// Print all possible states
for (Thread.State state : Thread.State.values()) {
System.out.println(" " + state);
}
System.out.println("\n--- Checking state with getState() ---");
Thread t = new Thread(() -> {
try { Thread.sleep(100); } catch (InterruptedException e) {}
});
System.out.println("Is NEW? " + (t.getState() == Thread.State.NEW));
t.start();
Thread.sleep(50);
System.out.println("Is TIMED_WAITING? " + (t.getState() == Thread.State.TIMED_WAITING));
t.join();
System.out.println("Is TERMINATED? " + (t.getState() == Thread.State.TERMINATED));
}
}Output
=== Thread State Enum Values === NEW RUNNABLE BLOCKED WAITING TIMED_WAITING TERMINATED Total states: 6
Common Mistakes
1. Confusing RUNNABLE with actually running
Example
RUNNABLE doesn't mean the thread IS running on CPU right now.
It means it's READY to run. The OS scheduler decides execution.
Java doesn't distinguish between "ready" and "running" — both are RUNNABLE.
2. Confusing BLOCKED vs WAITING
Example
BLOCKED: Waiting for a MONITOR LOCK (synchronized block/method)
→ Automatic — lock is acquired when available
WAITING: Waiting for a NOTIFICATION (wait/notify, join)
→ Requires explicit action (notify, notifyAll, thread completion)
Interview Questions
Q1: What are the different states of a thread in Java?
Answer: Six states defined in Thread.State: NEW (created, not started), RUNNABLE (ready/running), BLOCKED (waiting for monitor lock), WAITING (waiting indefinitely for notification), TIMED_WAITING (waiting with timeout), TERMINATED (completed execution).
Q2: What is the difference between BLOCKED and WAITING?
Answer: BLOCKED: thread is trying to enter a synchronized block but another thread holds the lock — it will automatically proceed when the lock is released. WAITING: thread explicitly called wait(), join(), or park() and must be notified/unparked to continue.
Q3: Can a thread go from TERMINATED back to RUNNABLE?
Answer: No. TERMINATED is a final state. Once a thread finishes execution, it cannot be restarted. Calling start() on a terminated thread throws IllegalThreadStateException.
Q4: What is the difference between WAITING and TIMED_WAITING?
Answer: WAITING waits indefinitely until explicitly notified (notify(), notifyAll()) or the target thread completes (join()). TIMED_WAITING has a timeout — it returns to RUNNABLE either when notified OR when the timeout expires, whichever comes first.
Q5: Is there a difference between RUNNABLE-ready and RUNNABLE-running?
Answer: In Java's thread model, no. Both are represented as RUNNABLE. The JVM doesn't distinguish between a thread waiting for CPU time (ready) and one currently executing (running). The OS scheduler handles this distinction transparently.
Q6: What state is a thread in during Thread.sleep()?
Answer: TIMED_WAITING. The thread is waiting for the specified time to elapse. It does NOT release any locks it holds during sleep.
Q8: What causes a thread to move from RUNNABLE to BLOCKED?
A: A thread moves to BLOCKED when it attempts to acquire an intrinsic lock (enter a synchronized block/method) that another thread currently holds. It remains BLOCKED until the lock becomes available. Only monitor locks cause BLOCKED state — ReentrantLock makes threads WAITING instead.
Q9: What is the difference between BLOCKED and WAITING states?
A: BLOCKED: thread is waiting to acquire a monitor lock (synchronized). WAITING: thread is waiting indefinitely for another thread's notification (wait(), join() without timeout, LockSupport.park()). BLOCKED is caused by lock contention; WAITING is caused by explicit coordination between threads.
Q10: Can a thread go back to NEW state after being TERMINATED?
A: No. Thread states are one-way: NEW → RUNNABLE → (BLOCKED/WAITING/TIMED_WAITING ↔ RUNNABLE) → TERMINATED. Once TERMINATED, the thread object exists but cannot be restarted. Calling start() again throws IllegalThreadStateException. Create a new Thread instance to run the task again.
Q11: What is TIMED_WAITING state?
A: A thread is in TIMED_WAITING when it's waiting with a specified timeout: Thread.sleep(ms), wait(ms), join(ms), LockSupport.parkNanos(), LockSupport.parkUntil(). The thread returns to RUNNABLE either when the timeout expires or when notified (whichever comes first).
Q12: How do you check a thread's current state programmatically?
A: Call thread.getState() which returns a Thread.State enum value: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, or TERMINATED. This is useful for monitoring, debugging, and testing. Note: the state may change by the time you use the returned value (it's a snapshot).
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Thread Life Cycle in Java.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, multithreading, thread, life
Related Java Master Course Topics
Continue learning this concept
MultithreadingCreating Threads in JavaComplete guide to creating threads in Java — extending Thread class, implementing Runnable interface, lambda expressions, comparison of approaches, and when to use each method.MultithreadingDaemon Threads in JavaComplete guide to Daemon Threads in Java — what they are, how they differ from user threads, JVM shutdown behavior, practical use cases like GC and auto-save, and common pitfalls.MultithreadingInter-Thread Communication in JavaComplete guide to Inter-Thread Communication in Java — wait(), notify(), notifyAll(), producer-consumer pattern, and how threads coordinate using object monitors.MultithreadingThread Class in JavaComplete guide to the Thread class in Java — constructors, important methods (sleep, join, yield, interrupt), thread naming, thread groups, and practical usage patterns.MultithreadingThread IntroductionComplete introduction to Multithreading in Java — what threads are, processes vs threads, why multithreading matters, concurrency vs parallelism, and how the JVM manages threads.MultithreadingThread Priority in JavaComplete guide to Thread Priority in Java — priority constants, setting priorities, how the thread scheduler uses priorities, priority inheritance, and why priorities are unreliable for correctness.