A thread moves through a series of states from creation to completion. The JVM manages these transitions and controls how threads execute.

Definition List

• Thread Life Cycle: The sequence of states a thread passes through during execution.
• Thread: A lightweight process that performs a specific task within a program.
• JVM (Java Virtual Machine): The runtime environment that manages thread execution.
• Thread State: The current status of a thread at a specific point in time.
• New State: The initial state of a thread after creation and before calling start().
• Runnable State: The state in which a thread is ready to run and waiting for CPU allocation.
• Waiting State: A state where a thread pauses execution until another thread or event signals it to continue.
• Terminated State: The final state of a thread after execution is completed.

Stages of the Thread Life Cycle

• New
• Runnable
• Waiting
• Terminated

Thread State Flow

New → Runnable → Waiting → Runnable → Terminated

1. New State

A thread begins its life cycle in the New state. The thread object is created but start() has not been called yet.

Example 01: New State

Thread t1 = new Thread();

2. Runnable State

After calling start(), the thread enters the Runnable state. It is eligible for execution and waiting for CPU time from the scheduler.

Example 02: Runnable State

t1.start();

3. Waiting State

A thread enters the Waiting state when it must pause for another thread or resource. Common causes include calling wait(), join(), or waiting for resource availability.

Example 03: Waiting State

thread.join();

4. Terminated State

A thread enters the Terminated state after completing its task. Once terminated, it cannot be restarted.

Example 04: Terminated State

public void run() {
    System.out.println("Task completed");
}

Full Thread State Transition Example

class MyThread extends Thread {

    public void run() {
        System.out.println("Thread is running...");
    }

    public static void main(String[] args) {

        MyThread t1 = new MyThread();

        System.out.println("State after creation: " + t1.getState());

        t1.start();

        System.out.println("State after start(): " + t1.getState());
    }
}

Output

State after creation: NEW
State after start(): RUNNABLE
Thread is running...

Best Practices

• Avoid unnecessary waiting — keep waiting periods short.
• Use synchronization carefully to avoid excessive blocking.
• Monitor thread states using getState() when debugging.
• Properly handle interruptions and thread-related exceptions.

FAQ

1. What are the main states in the Java thread life cycle?

The primary states are New, Runnable, Waiting and Terminated.

2. What happens when start() is called?

The thread moves from New to Runnable, making it eligible for execution.

3. Can a terminated thread be restarted?

No. Once a thread reaches the Terminated state, it cannot be started again.