Java Thread Life Cycle

In Multithreading, a thread executes independently and during the execution, it moves from one state to another state. A thread follows a complete life cycle for execution.

When a new thread is created, it is in a new state. It remains in this state until the program starts the thread using its start() method. This state is also known as the Born state.

When we call the start( ) method, then the thread moves from the New state to the Runnable state. This state is also known as a Ready state.

In this state a thread is ready for execution, execution control is passed to Thread-scheduler to finish its execution but it's up to Thread-scheduler to decide whether this thread should be executed or should be put on hold to give chance to other runnable threads.

Thread-Scheduler picks up a thread from the runnable thread pool and changes the state from Runnable to Running state, then the CPU starts executing this thread. A running thread can change state to Runnable, Dead, or Blocked depending on time slicing, thread completion of the run() method, or waiting for some resources.

A running thread may move into the waiting or blocked state due to various reasons like the sleep( ) method called, wait( ) method called, suspend( ) method called, and join( ) method called, etc.

When a thread is in the waiting or blocked state, it may move to a Runnable state due to reasons like sleep time completed, waiting time completed, notify( ) or notifyAll( ) method called, resume( ) method called, etc.

A thread in the Running state may move into the dead state due to either its execution completed or the stop( ) method called. The dead state is also known as the terminated state.

Implementation of Java Thread States

To get the current state of the thread, use Thread.getState() method. Java provides java.lang.Thread.State class that defines the ENUM constants for the state of a thread.

This state represents New state of a thread. This is the first state of any thread.

  class MyThread implements Runnable {
    public void run() {
      // Moving thread2 to the state timed waiting
      try {
        Thread.sleep(200);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
  
      System.out.println("State of thread1 while it called join() method on thread2 -" + 
                                                    TheadStatesExample.thread1.getState());
      try {
        Thread.sleep(300);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }
  public class TheadStatesExample implements Runnable {
    // Creating static type reference objects
    public static Thread thread1;
    public static TheadStatesExample obj;
  
    public static void main(String args[]) {
      obj = new TheadStatesExample();
      thread1 = new Thread(obj);
  
      // thread1 is newly created let's print it's status
      System.out.println("State of thread1 : " + thread1.getState());
      // Starting thread1 for execution
      thread1.start();
      // Now, thread1 is in running state let's print it's status
      System.out.println("State of thread1 : " + thread1.getState());
    }
  
    @Override
    public void run() {
      MyThread mythread = new MyThread();
      Thread thread2 = new Thread(mythread);
  
      // thread2 is newly created let's print it's status
      System.out.println("State of thread2 : " + thread2.getState());
      // Starting thread2 for execution
      thread2.start();
      // Now, thread1 is in running state let's print it's status
      System.out.println("State of thread2 : " + thread2.getState());
  
      try {
        // Moving thread1 to timed waiting state
        Thread.sleep(500);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
  
      System.out.println("After calling sleep() method, State of thread2 - "
                                                                    + thread2.getState());
      try {
        // waiting for thread2 to die
        thread2.join();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println("thread2 completed it's execution, State of thread2 - " 
                                                                    + thread2.getState());
    }
  }

State of thread1 : NEW
State of thread1 : RUNNABLE
State of thread2 : NEW
State of thread2 : RUNNABLE
State of thread1 while it called join() method on thread2 -TIMED_WAITING
After calling sleep() method, State of thread2 - TIMED_WAITING
thread2 completed it's execution, State of thread2 - TERMINATED

Java Thread Life Cycle

Implementation of Java Thread States

Thread Life Cycle - Interview Questions and Answers

Currently No Video available