Thread Lifecycle

🔄 Introduction to Thread Lifecycle in Java

In Java, threads are an integral part of building responsive and high-performing applications. A thread passes through multiple stages in its life, known collectively as the Thread Lifecycle. Understanding the lifecycle helps developers manage thread execution effectively and avoid concurrency issues.

🧬 What is the Thread Lifecycle?

The Thread Lifecycle represents the different states a thread can occupy from creation to termination. Java provides tools within the java.lang.Thread class to monitor and control these states. The lifecycle includes six main phases:

• New
• Runnable
• Running
• Blocked
• Waiting / Timed Waiting
• Terminated

🆕 New State

A thread is in the New state when it is created using the Thread class but hasn't started yet.

Thread t = new Thread(() -> System.out.println("Thread logic"));

🏃 Runnable State

When the start() method is called, the thread moves to the Runnable state. At this stage, it is eligible to run but is waiting for the CPU to schedule it.

t.start();  // Moves to Runnable state

⚙️ Running State

The thread enters the Running state when the thread scheduler selects it from the runnable pool. This is when the thread's run() method begins execution.

⛔ Blocked State

A thread enters the Blocked state when it attempts to access a synchronized block or method already being used by another thread. It remains blocked until it can gain access.

⏳ Waiting and Timed Waiting

- A thread is in Waiting state when it waits indefinitely for another thread to perform a specific action.
- In Timed Waiting, a thread waits for a specific amount of time.

// Timed waiting example
Thread.sleep(2000); // Thread sleeps for 2 seconds

🛑 Terminated State

Once the run() method finishes execution or the thread is stopped manually, it enters the Terminated state. It cannot be restarted after this point.

📊 Thread Lifecycle Diagram (Text Version)

New --> start() --> Runnable --> (Thread Scheduler) --> Running
   --> Waiting/Timed Waiting/Blocked --> Running
   --> Terminated (after run() or stop())

💡 Example Demonstrating Thread Lifecycle

class MyThread extends Thread {
    public void run() {
        try {
            System.out.println("Thread is running...");
            Thread.sleep(1000); // Timed Waiting
            System.out.println("Thread is awake...");
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted.");
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread t = new MyThread(); // New
        t.start(); // Runnable
        System.out.println("Thread state: " + t.getState());
    }
}

🧠 Why is Thread Lifecycle Important?

• Helps debug thread-related issues.
• Improves performance through better thread control.
• Essential for understanding multithreaded application behavior.

✅ Conclusion

The Thread Lifecycle in Java provides a clear picture of how threads are managed from creation to termination. By understanding and handling each state properly, you can write more stable, scalable, and high-performing Java applications that take full advantage of multithreading capabilities.