Understanding Thread Priority in Java: Why Caution is Key
Written on
Chapter 1: What is Thread Priority?
Thread priority refers to the execution order assigned by the operating system to different threads during scheduling. Higher priority threads are generally executed before those with lower priority. In Java, thread priority is designated within a range from 1 to 10, with the default being 5.
Despite this defined range, not all operating systems support all ten levels of prioritization; many only provide three: low, medium, and high. It's crucial to note that Java merely offers a reference value for thread priority, and the operating system ultimately determines the thread's final priority. Therefore, the execution order is predominantly governed by the operating system's scheduler, while thread priority must be established before the thread is invoked.
Generally, threads with elevated priorities have a higher likelihood of being executed before their lower-priority counterparts. To adjust a thread's priority, we utilize the setPriority() method from the Thread class.
public class Demo {
public static void main(String[] args) {
Thread a = new Thread();
System.out.println("Default thread priority: " + a.getPriority());
Thread b = new Thread();
b.setPriority(9);
System.out.println("Set thread priority: " + b.getPriority());
}
}
Output:
Default thread priority: 5
Set thread priority: 9
Chapter 2: Why Caution is Advised
Given the ability to set thread priorities, one might wonder if this feature can be reliably used to dictate the order of execution for threads in application logic. The answer is a resounding no! ❌
Thread priorities in Java are not particularly dependable; the priority assigned to a thread is merely a suggestion to the operating system, which may choose to disregard it. The actual order of execution is influenced by the operating system's scheduling algorithm.
To illustrate this with code:
public class TestExecuteOrder {
static class MyRunnable implements Runnable {
@Override
public void run() {
System.out.printf("Current thread: %s, priority: %d%n",
Thread.currentThread().getName(),
Thread.currentThread().getPriority());
}
}
public static void main(String[] args) {
Thread t1 = new Thread(new MyRunnable());
t1.setPriority(1);
Thread t2 = new Thread(new MyRunnable());
t2.setPriority(5);
Thread t3 = new Thread(new MyRunnable());
t3.setPriority(10);
t3.start();
t2.start();
t1.start();
}
}
When executed, one might expect the output to follow the order of 10, 5, 1. However, the actual output can be surprising:
Current thread: Thread-1, priority: 5
Current thread: Thread-2, priority: 10
Current thread: Thread-0, priority: 1
Here, the thread with priority 5 executed before the one with priority 10, demonstrating that priority settings are indeed unreliable. 😆
In a previous article, we discussed that threads must belong to a thread group. What occurs if a thread's priority exceeds that of its group? Let's verify it with the following code:
public class ThreadGroupOrder {
public static void main(String[] args) {
ThreadGroup myThreadGroup = new ThreadGroup("myThreadGroup");
myThreadGroup.setMaxPriority(6);
Thread myThread = new Thread(myThreadGroup, "myThread");
myThread.setPriority(8);
System.out.println("Thread group priority: " + myThreadGroup.getMaxPriority());
System.out.println("Thread priority: " + myThread.getPriority());
}
}
Output:
Thread group priority: 6
Thread priority: 6
If a thread's priority exceeds that of its group, the thread's priority is invalidated and adjusted to match the group's maximum.
In Conclusion
That's all for now! Until next time! 🤭 If you found this article beneficial, please show your support with a clap 👏 and follow for more insights. Thank you! ╰(°▽°)╯ I'm Sea Breeze, eager to embark on this journey of learning with you. ❤️