Groovy - Thread Life Cycle

Life Cycle of a Thread

The life cycle of a thread in Groovy refers to the various states of a thread goes through. For example, a thread is born, started, runs, and then dies. Thread class defines the life cycle and various states of a thread.

Flow Chart of Thread Life Cycle

The following diagram shows the complete life cycle of a thread.

States of a Thread Life Cycle

Following are the stages of the life cycle −

• New − A new thread begins its life cycle in the new state. It remains in this state until the program starts the thread. It is also referred to as a born thread.

• Runnable − After a newly born thread is started, the thread becomes runnable. A thread in this state is considered to be executing its task.

• Waiting − Sometimes, a thread transitions to the waiting state while the thread waits for another thread to perform a task. A thread transitions back to the runnable state only when another thread signals the waiting thread to continue executing.

• Timed Waiting − A runnable thread can enter the timed waiting state for a specified interval of time. A thread in this state transitions back to the runnable state when that time interval expires or when the event it is waiting for occurs.

• Terminated (Dead) − A runnable thread enters the terminated state when it completes its task or otherwise terminates.

Example - Demonstrating Thread States

In this example, we're creating two threads by extending the Thread class. We're printing each state of the thread. When a thread object is created, its state is NEW; when start() method is called, state is START; when run() method is called, state is RUNNING; When a thread finished the processing the run() method, it went to DEAD state.

Example.groovy

class Example {
   static void main(String[] args) {
      ThreadDemo thread1 = new ThreadDemo( "Thread-1");
      ThreadDemo thread2 = new ThreadDemo( "Thread-2");
      thread1.start();
      thread2.start();
   }   
}
class ThreadDemo extends Thread {

   private Thread t;
   private String threadName;

   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Thread: " + threadName + ", " + "State: New");
   }
   void run() {
      println("Thread: " + threadName + ", " + "State: Running");
      for(int i = 4; i > 0; i--) {
         println("Thread: " + threadName + ", " + i);
      }
      println("Thread: " + threadName + ", " + "State: Dead");
   }
   void start () {
      println("Thread: " + threadName + ", " + "State: Start");
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

Output

The above program produces the following output −

Thread: Thread-1, State: New
Thread: Thread-2, State: New
Thread: Thread-1, State: Start
Thread: Thread-2, State: Start
Thread: Thread-1, State: Running
Thread: Thread-2, State: Running
Thread: Thread-2, 4
Thread: Thread-2, 3
Thread: Thread-2, 2
Thread: Thread-2, 1
Thread: Thread-2, State: Dead
Thread: Thread-1, 4
Thread: Thread-1, 3
Thread: Thread-1, 2
Thread: Thread-1, 1
Thread: Thread-1, State: Dead

Example - Checking states of Thread created using Thread Class

In this example, we're using sleep() method to introduce some delay in processing and to show case the parallel processing using threads. We're creating two threads by extending the Thread class. We're printing each state of the thread. When a thread object is created, its state is NEW; when start() method is called, state is START; when run() method is called, state is RUNNING; in case sleep() is called, then thread goes to WAITING state; When a thread finished the processing the run() method, it went to DEAD state.

Example.groovy

class Example {
   static void main(String[] args) {
      ThreadDemo thread1 = new ThreadDemo( "Thread-1");
      ThreadDemo thread2 = new ThreadDemo( "Thread-2");
      thread1.start();
      thread2.start();
   }   
}
class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;

   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Thread: " + threadName + ", " + "State: New");
   }

   void run() {
      println("Thread: " + threadName + ", " + "State: Running");
      try {
         for(int i = 4; i > 0; i--) {
            println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            println("Thread: " + threadName + ", " + "State: Waiting");
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         println("Thread " +  threadName + " interrupted.");
      }
      println("Thread: " + threadName + ", " + "State: Dead");
   }

   void start () {
      println("Thread: " + threadName + ", " + "State: Start");
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

Output

The above program produces the following output −

Thread: Thread-1, State: New
Thread: Thread-2, State: New
Thread: Thread-1, State: Start
Thread: Thread-2, State: Start
Thread: Thread-1, State: Running
Thread: Thread-1, 4
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Running
Thread: Thread-2, 4
Thread: Thread-2, State: Waiting
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-2, State: Waiting
Thread: Thread-1, State: Waiting
Thread: Thread-2, 2
Thread: Thread-1, 2
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Waiting
Thread: Thread-2, 1
Thread: Thread-2, State: Waiting
Thread: Thread-1, 1
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Dead
Thread: Thread-1, State: Dead

Example - Checking states of Thread created using Runnable Interface

In this example, we're creating two threads by implementing the Runnable class. We're printing each state of the thread. When a thread object is created, its state is NEW; when start() method is called, state is START; when run() method is called, state is RUNNING; in case sleep() is called, then thread goes to WAITING state; When a thread finished the processing the run() method, it went to DEAD state.

Example.groovy

class Example {
   static void main(String[] args) {
      ThreadDemo thread1 = new ThreadDemo( "Thread-1");
      ThreadDemo thread2 = new ThreadDemo( "Thread-2");
      thread1.start();
      thread2.start();
   }   
}
class ThreadDemo implements Runnable {
   private Thread t;
   private String threadName;
   ThreadDemo( String name) {
      threadName = name;
      println("Thread: " + threadName + ", " + "State: New");
   }
   void run() {
      println("Thread: " + threadName + ", " + "State: Running");
      try {
         for(int i = 4; i > 0; i--) {
            println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            println("Thread: " + threadName + ", " + "State: Waiting");
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      println("Thread: " + threadName + ", " + "State: Dead");
   }

   void start () {
      println("Thread: " + threadName + ", " + "State: Start");
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

Output

Thread: Thread-1, State: New
Thread: Thread-2, State: New
Thread: Thread-1, State: Start
Thread: Thread-2, State: Start
Thread: Thread-1, State: Running
Thread: Thread-1, 4
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Running
Thread: Thread-2, 4
Thread: Thread-2, State: Waiting
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-2, State: Waiting
Thread: Thread-1, State: Waiting
Thread: Thread-2, 2
Thread: Thread-1, 2
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Waiting
Thread: Thread-2, 1
Thread: Thread-2, State: Waiting
Thread: Thread-1, 1
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Dead
Thread: Thread-1, State: Dead