Understanding Thread Priority in Java

Developer.com content and product recommendations are editorially independent. We may earn money when you click on links to our partners. Find out more.

Since Java is a multi-threaded programming language, it allows developers to execute multiple threads simultaneously. Each thread represents an independent flow of control within the program. Each thread is assigned a priority at creation that determines its relative importance to the JVM (Java Virtual Machine). They usually range from 1 to 10, with 5 being the default. In this article, we’ll learn how thread priority helps optimize performance and responsiveness in multi-threaded applications.

Understanding thread priority

The thread priority is an integer value assigned to each thread, ranging from Thread.MIN_PRIORITY (which is usually 1) to Thread.MAX_PRIORITY (which is usually 10). These constants are defined in Thread class.

• Thread.MIN_PRIORITY: The minimum priority a thread can have.
• Thread.MAX_PRIORITY: The maximum priority a thread can have.
• Thread.NORM_PRIORITY: The default priority assigned to a thread (which is usually 5).

When a thread is created, it inherits the priority of the thread that created it. This is because threads are often created to perform subtasks of the creating thread and it makes sense that they share the same priority.

Priority scheduling

The Java Virtual Machine (JVM) uses priority scheduling to determine which thread to execute. In priority scheduling, the thread with the highest priority is selected for execution. If two threads have the same priority, they are distributed in a round-robin fashion. This is a scheduling technique where each thread is assigned a fixed time slot and the JVM switches between them in a round robin fashion.

However, it is important to note that priority is a thread proposal, not a strict order of execution. The JVM’s scheduler is not even required to strictly follow priority levels. It is up to the underlying operating system and JVM implementation to interpret and enforce thread priorities.

Setting thread priority

You can set the thread priority using setPriority(int priority) method it provides Thread class. For example, if you want to set the priority of a named thread myThread to the highest priority, you would use:

Thread myThread = new Thread();
myThread.setPriority(Thread.MAX_PRIORITY);

We can also set a custom priority by passing an int value that is between the MIN_PRIORITY and MAX_PRIORITY values:

Thread myThread = new Thread();
myThread.setPriority(7);

Some tips for using thread priority in Java

While thread priority can be a useful tool, it’s important to use it judiciously. Here are some tips for working with thread priorities:

1. Avoid over-reliance on priority
   Over-reliance on thread priority can lead to non-portable and non-deterministic behavior. Different JVM implementations and operating systems may handle thread priorities differently. Therefore, it is best to design your application to be robust and efficient without relying solely on priority.
2. Use priority to lead, not control
   Think of thread priority as a suggestion to the JVM about the relative importance of threads. It is not guaranteed that a thread will be scheduled in any particular order. So use thread priorities to guide the scheduler, but don’t rely on them for critical program functions.
3. Avoid priority inversion
   Priority inversion occurs when a higher priority thread waits for a resource held by a lower priority thread. This may lead to unexpected delays. To avoid priority inversion, use synchronization constructs such as locks and semaphores appropriately.
4. Test thoroughly
   Because thread scheduling behavior can vary across JVMs and operating systems, it’s important to thoroughly test your application on target platforms to ensure that the thread priorities you choose have the desired effect.

Read: Thread safety in Java

Example scenario

Let’s consider a real-world scenario where understanding and managing thread priorities can be critical.

Scenario: Imagine developing a real-time system that monitors various sensors and controls actuators. You have multiple threads that perform different tasks, such as reading sensor data, processing it, and sending control signals.

In this scenario, you can assign a higher priority to threads responsible for processing sensor data and controlling actuators. This ensures that these critical tasks are executed promptly, even if there are other threads performing less critical operations.

Here’s how it might look in terms of Java code:

class SensorThread extends Thread 
   @Override
   public void run() 
      while (true) 
         // Simulated sensor reading
         double sensorData = Math.random() * 100; // Replace with actual sensor reading logic

         // Process sensor data (e.g., send to a controller)
         processSensorData(sensorData);

         try 
            Thread.sleep(1000); // Simulated delay between readings
          catch (InterruptedException e) 
            e.printStackTrace();
         
      
   

   private void processSensorData(double data) 
      // Add your sensor data processing logic here
      System.out.println("Sensor Data: " + data);
   


class ActuatorThread extends Thread 
   @Override
   public void run() 
      while (true) 
         // Simulated actuator control
         // Replace with actual control logic
         boolean controlSignal = Math.random() > 0.5;

         // Send control signal to actuators
         controlActuators(controlSignal);

         try 
            Thread.sleep(2000); // Simulated delay between control signals
          catch (InterruptedException e) 
            e.printStackTrace();
         
      
   

   private void controlActuators(boolean signal) 
      // Add your actuator control logic here
      System.out.println("Control Signal Sent: " + signal);
   


public class RealTimeSystem 
   public static void main(String[] args) 
      SensorThread sensorThread = new SensorThread();
      ActuatorThread actuatorThread = new ActuatorThread();

      // Give sensor and actuator threads highest priorities
      sensorThread.setPriority(Thread.MAX_PRIORITY);
      actuatorThread.setPriority(Thread.MAX_PRIORITY);

      // Start threads
      sensorThread.start();
      actuatorThread.start();
   

Final thoughts on thread priority in Java

Thread priority is a useful tool for guiding the JVM’s thread scheduler, but it should be used judiciously. It is important to remember that thread priority is not a strict guarantee of execution order, and over-reliance on it can lead to non-portable and non-deterministic behavior.

When using thread priorities, consider the relative importance of different tasks in your application. Assign higher priorities to threads responsible for critical operations, but always design your application without relying solely on priority.

Now that you’ve learned about thread safety in Java, we suggest you check out our guide covering best practices for threads in Java.