Thread Priority

In Java, every thread has a priority, which serves as a hint to the Thread Scheduler about the order in which threads should execute.

Threads with higher priority are generally given preference over lower-priority threads. However, priority does not guarantee exact execution order, as thread scheduling depends on the JVM, OS, and hardware.

What is Thread Priority?

Thread priority is an integer value from 1 to 10 that indicates the importance of a thread.

By default, a thread inherits the priority of the thread that created it.

Usually, this is:

Thread.NORM_PRIORITY// value = 5

Why Use Thread Priority?

Thread priority helps the scheduler decide which thread should get more CPU time when multiple threads are waiting.

• High priority → more chances to execute
• Low priority → fewer chances

But scheduling is not guaranteed. The OS and JVM ultimately decide.

Setting and Getting Thread Priority

In Java, every thread has a priority, which is an integer value ranging from 1 to 10, indicating the relative importance of that thread. The thread scheduler uses this priority as a hint to decide which thread should run first.

The priority can be set, retrieved, or inherited from the parent thread.

1. Setting Thread Priority

You can set a thread’s priority using the setPriority(int p) method:

thread.setPriority(Thread.MAX_PRIORITY);// value 10

Explanation:

• thread is the object of your thread.
• setPriority() takes an integer between 1 (lowest) and 10 (highest).
• Java provides predefined constants for convenience:
  • Thread.MIN_PRIORITY → 1
  • Thread.NORM_PRIORITY → 5 (default)
  • Thread.MAX_PRIORITY → 10
• Setting a higher priority gives the thread more chances to get CPU time, but it does not guarantee it will run first.

2. Getting Thread Priority

You can check the current priority of a thread using the getPriority() method:

intp= thread.getPriority();
System.out.println("Thread Priority: " + p);

Explanation:

• getPriority() returns an integer representing the thread’s current priority.
• This helps in debugging or logging to know how important a thread is relative to others.

3. Default Thread Priority

• When you create a new thread, it inherits the priority of its parent thread.

  For example, if the main thread has priority 5 (normal), any thread created by it will also start with priority 5 unless explicitly changed.

• The main thread usually has Thread.NORM_PRIORITY (5).

Example:

Threadt1=newThread(() -> System.out.println("Running..."));
System.out.println(t1.getPriority());// Output: 5 (inherited from main thread)

If you want a thread to be executed more often or sooner than others, you can explicitly set its priority. But remember, it’s just a hint to the scheduler, not a guarantee.

Thread Priority Example

classMyThreadextendsThread {

publicMyThread(String name) {
super(name);
    }

publicvoidrun() {
        System.out.println("Running: " + getName() +
" | Priority: " + getPriority());
    }
}

publicclassTestPriority {
publicstaticvoidmain(String[] args) {

MyThreadt1=newMyThread("Low Priority Thread");
MyThreadt2=newMyThread("Medium Priority Thread");
MyThreadt3=newMyThread("High Priority Thread");

        t1.setPriority(Thread.MIN_PRIORITY);// 1
        t2.setPriority(Thread.NORM_PRIORITY);// 5
        t3.setPriority(Thread.MAX_PRIORITY);// 10

        t1.start();
        t2.start();
        t3.start();
    }
}

Possible Output (varies by OS/JVM):

Running:HighPriorityThread|Priority:10
Running:MediumPriorityThread|Priority:5
Running:LowPriorityThread|Priority:1

Actual execution order may differ.

Important Notes

1. Priority is just a hint, not a command.
2. High priority does not guarantee faster execution.
3. Threads inherit their parent thread’s priority.
4. Daemon or non-daemon status does not affect priority.
5. Misusing priority may starve lower-priority threads and reduce performance.

Real-Life Analogy

Imagine a hospital:

• Emergency patient → Priority 10
• Normal OPD patient → Priority 5
• Routine checkup → Priority 1

Doctors attend emergencies first, similar to how the CPU gives preference to higher-priority threads.

When to Use Thread Priority

• Background tasks vs. UI tasks
• Animations vs. logging
• Real-time tasks requiring faster response

Do not rely on thread priority for precise scheduling; it is just a hint to the scheduler.

Conclusion

• Thread priority range: 1 (MIN) – 10 (MAX)
• Default: 5 (NORM_PRIORITY)
• Use setPriority() to set and getPriority() to read thread priority
• High priority may get more CPU time, but execution order is not guaranteed
• Always use priority judiciously to avoid thread starvation