Java setPriority() Method

In Java, when working with multi-threaded applications, it is crucial to manage thread priorities effectively. Prioritizing threads can help us to control how the operating system schedules threads for execution. Java provides a method called setPriority() to set the priority of a thread, allowing us to influence the order in which threads are executed. In this section, we will explore the setPriority() method in Java in detail, including its usage, explanation, and complete code examples.

Thread Priority

In Java, threads are scheduled for execution by the operating system's thread scheduler. Each thread has a priority associated with it, which is an integer value ranging from 1 to 10. Threads with higher priority values are given preference by the scheduler and tend to be executed before lower-priority threads. However, thread priorities do not guarantee strict execution order, as they depend on the underlying operating system.

The Thread class in Java provides the setPriority() and getPriority() methods to manipulate and retrieve the priority of a thread, respectively.

Thread Priority Constants

Java's Thread class defines three constant properties related to thread priorities:

public static int MIN_PRIORITY: The constant signifies the minimum priority a thread can have, with a value of 1.
public static int NORM_PRIORITY: It represents the default or normal priority, typically set to 5.
public static int MAX_PRIORITY: The constant stands for the maximum priority a thread can possess, with a value of 10.

Java setPriority() Method

The setPriority() method allows us to set the priority of a thread. Its syntax is as follows:

Here, priority is the new priority we want to assign to the thread. It must be an integer within the range of MIN_PRIORITY (1) to MAX_PRIORITY (10).

Exception Handling

The setPriority() method can throw two exceptions:

IllegalArgumentException: An exception is thrown if we attempt to set a priority outside the range of MIN_PRIORITY to MAX_PRIORITY.
SecurityException: It is thrown if the current thread does not have permission to modify the priority of the target thread.

newPriority:

The new priority value for the thread, which should be an integer between 1 and 10, inclusive.

Example 1: Setting Maximum Priority

MaxPriorityThread.java

public class MaxPriorityThread extends Thread {
    public void run() {
        System.out.println("Running with maximum priority...");
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread: " + Thread.currentThread().getName() + " - Count: " + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        MaxPriorityThread thread1 = new MaxPriorityThread();
        thread1.setPriority(Thread.MAX_PRIORITY);
        thread1.start();
    }
}

Output:

Running with maximum priority ...
Thread: Thread-0 - Count: 0
Thread: Thread-0 - Count: 1
Thread: Thread-0 - Count: 2
Thread: Thread-0 - Count: 3
Thread: Thread-0 - Count: 4

Explanation

In this example, we create a thread thread1 and set its priority to the maximum value using setPriority(Thread.MAX_PRIORITY).

Example 2: Setting Minimum Priority

MinPriorityThread.java

public class MinPriorityThread extends Thread {
    public void run() {
        System.out.println("Running with minimum priority...");
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread: " + Thread.currentThread().getName() + " - Count: " + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        MinPriorityThread thread1 = new MinPriorityThread();
        thread1.setPriority(Thread.MIN_PRIORITY);
        thread1.start();
    }
}

Output:

Running with normal priority...
Thread: Thread-0 - Count: 0
Thread: Thread-0 - Count: 1
Thread: Thread-0 - Count: 2
Thread: Thread-0 - Count: 3
Thread: Thread-0 - Count: 4

Explanation

Here, we set the priority of thread1 to the minimum value using setPriority(Thread.MIN_PRIORITY).

Example 3: Setting Normal Priority

NormPriorityThread.java

public class NormPriorityThread extends Thread {
    public void run() {
        System.out.println("Running with normal priority...");
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread: " + Thread.currentThread().getName() + " - Count: " + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace ();
            }
        }
    }
    public static void main (String [] args) {
        NormPriorityThread thread1 = new NormPriorityThread();
        thread1.setPriority(Thread.NORM_PRIORITY);
        thread1.start();
    }
}

Output:

Running with normal priority...
Thread: Thread-0 - Count: 0
Thread: Thread-0 - Count: 1
Thread: Thread-0 - Count: 2
Thread: Thread-0 - Count: 3
Thread: Thread-0 - Count: 4

Explanation

In this case, we set the priority to the default value using setPriority(Thread.NORM_PRIORITY).

Example 4: User-Defined Priority

CustomPriorityThread.java

public class CustomPriorityThread extends Thread {
    public void run() {
        System.out.println("Running with custom priority...");
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread: " + Thread.currentThread().getName() + " - Count: " + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        CustomPriorityThread thread1 = new CustomPriorityThread();
        CustomPriorityThread thread2 = new CustomPriorityThread();
        thread1.setPriority(4);
        thread2.setPriority(7);
        thread1.start();
        thread2.start();
    }
}

Output:

Running with custom priority...
Thread: Thread-0 - Count: 0
Thread: Thread-0 - Count: 1
Thread: Thread-0 - Count: 2
Thread: Thread-0 - Count: 3
Thread: Thread-0 - Count: 4
Running with custom priority...
Thread: Thread-1 - Count: 0
Thread: Thread-1 - Count: 1
Thread: Thread-1 - Count: 2
Thread: Thread-1 - Count: 3
Thread: Thread-1 - Count: 4

Explanation

In this example, we create two custom priority threads and set their priorities to 4 and 7, respectively, using setPriority().

Example 5: Handling IllegalArgumentException

InvalidPriorityThread.java

public class InvalidPriorityThread 
extends Thread {
    public void run() {
        System.out.println("Running...");
    }
    public static void main(String[] args) {
        InvalidPriorityThread thread1 = new InvalidPriorityThread();
        InvalidPriorityThread thread2 = new InvalidPriorityThread();
        // Attempt to set an invalid priority (greater than 10)
        try {
            thread1.setPriority(12);
        } catch (IllegalArgumentException e) {
            System.out.println("IllegalArgumentException: " + e.getMessage());
        }
        thread2.setPriority(7);
        System.out.println("Priority of thread t2 is: " + thread2.getPriority());
        thread1.start();
    }
}

Output:

IllegalArgumentException: Priority out of range: 12
Priority of thread t2 is: 7
Running...

Explanation

In this example, we intentionally attempt to set an invalid priority (greater than 10) for thread1, which results in an IllegalArgumentException. The priority for thread2 is set to 7 and is printed as well.

Example of setPriority() Method

Let's walk through an example to see how the setPriority() method works in practice. In this example, we will create two threads with different priorities and observe their execution order:

ThreadPriorityExample.java

public class ThreadPriorityExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable(), "Thread 1");
        Thread thread2 = new Thread(new MyRunnable(), "Thread 2");
        // Set priorities for the threads
        thread1.setPriority(Thread.MIN_PRIORITY); // Priority 1
        thread2.setPriority(Thread.MAX_PRIORITY); // Priority 10
        // Start the threads
        thread1.start();
        thread2.start();
    }
    static class MyRunnable implements Runnable {
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + " - Count: " + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Output:

Thread 2 - Count: 0
Thread 1 - Count: 0
Thread 2 - Count: 1
Thread 1 - Count: 1
Thread 2 - Count: 2
Thread 1 - Count: 2
Thread 2 - Count: 3
Thread 1 - Count: 3
Thread 2 - Count: 4
Thread 1 - Count: 4

Explanation

We create two threads (thread1 and thread2) and assign them different priorities using setPriority() method. thread1 is assigned the minimum priority (1), while thread2 is assigned the maximum priority (10). Both threads execute a simple run method that counts from 0 to 4, printing their names and the current count. We start both threads.

Best Practices and Considerations

When using the setPriority() method, consider the following best practices and considerations:

Avoid excessive priority tuning: Changing thread priorities should be done sparingly and with a clear understanding of the application's requirements. Excessive use of thread priorities can lead to unpredictable behavior and reduced code maintainability.
Prefer high-level concurrency constructs: Whenever possible, use high-level concurrency constructs like the java.util.concurrent package, which abstracts away many low-level details, including thread priorities.
Thread priority is platform-dependent: Thread priorities may not behave consistently across different operating systems and Java implementations. Rely on priorities only when necessary.
Avoid depending on exact execution order: Thread priority is a hint to the operating system's scheduler, and it doesn't guarantee a precise execution order. Design your code to be thread-safe and robust regardless of the order in which threads run.

Conclusion

In Java, the setPriority() method is a tool for influencing the scheduling of threads in a multi-threaded application. While it can be useful in specific scenarios, it's essential to use it judiciously and understand that thread priority is platform-dependent and doesn't provide strict execution order guarantees. When designing multi-threaded applications, consider using higher-level concurrency constructs and prioritize writing thread-safe code over manipulating thread priorities.

Next TopicMutator Methods in Java

← prev next →