Groovy - Thread Priorities

Priority of a Thread in Groovy

Every Groovy thread has a priority that helps the operating system determine the order in which threads are scheduled. You can get and set the priority of a Thread. Thread class provides methods and constants for working with the priorities of a Thread.

Threads with higher priority are more important to a program and should be allocated processor time before lower-priority threads. However, thread priorities cannot guarantee the order in which threads execute and are very much platform dependent.

Built-in Property Constants of Thread Class

Groovy thread priorities are in the range between MIN_PRIORITY (a constant of 1) and MAX_PRIORITY (a constant of 10). By default, every thread is given priority NORM_PRIORITY (a constant of 5).

• MIN_PRIORITY: Specifies the minimum priority that a thread can have.

• NORM_PRIORITY: Specifies the default priority that a thread is assigned.

• MAX_PRIORITY: Specifies the maximum priority that a thread can have.

Thread Priority Setter and Getter Methods

• Thread.getPriority() Method− This method is used to get the priority of a thread.

• Thread.setPriority() Method− This method is used to set the priority of a thread, it accepts the priority value and updates an existing priority with the given priority.

Example - Usage of Thread Priority in Groovy

In this example, we're showing a simple one thread program where we're not declaring any thread and checking the thread name and priority in the program execution.

Example.groovy

class Example {
   void printName() {
      println("Thread Name: " + Thread.currentThread().getName());
      println("Thread Priority: " +Thread.currentThread().getPriority());
   }	
   static void main(String[] args) {
      Example thread = new Example();
      thread.printName();	   
   }
}

Output

The above program produces the following output −

Thread Name: main
Thread Priority: 5

Example - Assigning a Priority to a Thread

In this example, we've created a ThreadDemo class which extends Thread class. We've created three threads. Each thread is assigned a priority. In run() method, we're printing the priorities and in output, it is reflecting in threads execution.

Example.groovy

class Example {
   static void main(String[] args) {
      ThreadDemo thread1 = new ThreadDemo();
      ThreadDemo thread2 = new ThreadDemo();
      ThreadDemo thread3 = new ThreadDemo();
      thread1.setPriority(Thread.MAX_PRIORITY);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread3.setPriority(Thread.NORM_PRIORITY);
      thread1.start();	  
      thread2.start();
      thread3.start();
   }
}
class ThreadDemo extends Thread {
    void run() {
      println("Thread Name: " + Thread.currentThread().getName() 
         + ", Thread Priority: " +Thread.currentThread().getPriority());
      for(int i = 4; i > 0; i--) {
         println("Thread: " + Thread.currentThread().getName() + ", " + i); 
      }
      try {
         Thread.sleep(50);
      } catch (InterruptedException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
   }
   void start () {
      super.start();
   }
}

Output

The above program produces the following output −

Thread Name: Thread-2, Thread Priority: 5
Thread Name: Thread-1, Thread Priority: 1
Thread Name: Thread-0, Thread Priority: 10
Thread: Thread-1, 4
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-0, 4
Thread: Thread-1, 2
Thread: Thread-2, 3
Thread: Thread-0, 3
Thread: Thread-0, 2
Thread: Thread-0, 1
Thread: Thread-2, 2
Thread: Thread-2, 1
Thread: Thread-1, 1

Example - Threads with Normal Priorities

In this example, we've created a ThreadDemo class which extends Thread class. We've created three threads. As we're not setting any priority, each thread has a normal priority. In run() method, we're printing the priorities and in output, threads are executing in any order.

Example.groovy

class Example {
   static void main(String[] args) {
      ThreadDemo thread1 = new ThreadDemo();
      ThreadDemo thread2 = new ThreadDemo();
      ThreadDemo thread3 = new ThreadDemo();
      thread1.start();	  
      thread2.start();
      thread3.start();
   }
}
class ThreadDemo extends Thread {
   void run() {
      println("Thread Name: " + Thread.currentThread().getName() 
         + ", Thread Priority: " +Thread.currentThread().getPriority());
      for(int i = 4; i > 0; i--) {
         println("Thread: " + Thread.currentThread().getName() + ", " + i); 
      }
      try {
         Thread.sleep(50);
      } catch (InterruptedException e) {
         
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
   }
   void start () {
      super.start();
   }
}

Output

The above program produces the following output −

Thread Name: Thread-1, Thread Priority: 5
Thread Name: Thread-2, Thread Priority: 5
Thread Name: Thread-0, Thread Priority: 5
Thread: Thread-2, 4
Thread: Thread-1, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-0, 4
Thread: Thread-2, 2
Thread: Thread-1, 2
Thread: Thread-2, 1
Thread: Thread-0, 3
Thread: Thread-1, 1
Thread: Thread-0, 2
Thread: Thread-0, 1