Groovy - Thread Control

Groovy provides complete control over multithreaded program. You can develop a multithreaded program which can be suspended, resumed, or stopped completely based on your requirements. There are various static methods which you can use on thread objects to control their behavior.

Methods for Controlling Groovy Thread

Following table lists down the methods for controlling a thread in Groovy −

Example - Thread Control in Groovy

Example.groovy

class Example {
   static void main(String[] args) {
      RunnableDemo r1 = new RunnableDemo( "Thread-1");
      r1.start();

      RunnableDemo r2 = new RunnableDemo( "Thread-2");
      r2.start();

      try {
         Thread.sleep(1000);
         r1.suspend();
         println("Suspending First Thread");
         Thread.sleep(1000);
         r1.resume();
         println("Resuming First Thread");
         
         r2.suspend();
         println("Suspending thread Two");
         Thread.sleep(1000);
         r2.resume();
         println("Resuming thread Two");
      } catch (InterruptedException e) {
         println("Main thread Interrupted");
      }
	  
      try {
         println("Waiting for threads to finish.");
         r1.t.join();
         r2.t.join();
      } catch (InterruptedException e) {
         println("Main thread Interrupted");
      }
      println("Main thread exiting.");
   }
}
class RunnableDemo implements Runnable {
   Thread t;
   private String threadName;
   boolean suspended = false;

   RunnableDemo( String name) {
      threadName = name;
      println("Creating " +  threadName );
   }
   
   void run() {
      println("Running " +  threadName );
      try {
         for(int i = 10; i > 0; i--) {
            println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(300);
            synchronized(this) {
               while(suspended) {
                  wait();
               }
            }
         }
      } catch (InterruptedException e) {
         println("Thread " +  threadName + " interrupted.");
      }
      println("Thread " +  threadName + " exiting.");
   }

   void start () {
      println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
   
   void suspend() {
      suspended = true;
   }
   
   synchronized void resume() {
      suspended = false;
      notify();
   }
}

Output

The above program produces the following output −

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 10
Running Thread-2
Thread: Thread-2, 10
Thread: Thread-1, 9
Thread: Thread-2, 9
Thread: Thread-1, 8
Thread: Thread-2, 8
Thread: Thread-1, 7
Thread: Thread-2, 7
Suspending First Thread
Thread: Thread-2, 6
Thread: Thread-2, 5
Thread: Thread-2, 4
Resuming First Thread
Suspending thread Two
Thread: Thread-1, 6
Thread: Thread-1, 5
Thread: Thread-1, 4
Thread: Thread-1, 3
Resuming thread Two
Thread: Thread-2, 3
Waiting for threads to finish.
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.
Main thread exiting.