3. What is Thread priority?

Thread priority in Java determines the relative importance of a thread, which can influence the order in which threads are scheduled for execution by the JVM’s thread scheduler. Threads with higher priority are generally given preference over threads with lower priority when CPU resources are limited.

Key Points about Thread Priority:

Priority Levels:
- Each thread is assigned a priority, which is an integer value between Thread.MIN_PRIORITY (1) and Thread.MAX_PRIORITY (10). The default priority is Thread.NORM_PRIORITY (5).
- Higher numbers indicate higher priority.
Influence on Scheduling:
- The thread priority is a hint to the thread scheduler. In most JVMs, threads with higher priorities are scheduled before those with lower priorities.
- However, thread priority does not guarantee exact execution order. The actual scheduling depends on the operating system’s thread scheduling algorithm.
Setting Thread Priority:
- You can set the priority of a thread using the setPriority(int priority) method.
- Example:
  
  Thread thread = new Thread(); thread.setPriority(Thread.MAX_PRIORITY); // Sets the highest priority (10)
  
  1
  2
  
  Thread thread = new Thread();
  thread.setPriority(Thread.MAX_PRIORITY); // Sets the highest priority (10)
Getting Thread Priority:
- You can retrieve a thread’s priority using the getPriority() method.
- Example:
  
  int priority = thread.getPriority(); // Retrieves the priority of the thread
  
  1
  
  int priority = thread.getPriority(); // Retrieves the priority of the thread
Range of Priorities:
- Thread.MIN_PRIORITY (1): The lowest priority.
- Thread.NORM_PRIORITY (5): The default priority.
- Thread.MAX_PRIORITY (10): The highest priority.

Example of Thread Priority in Java:

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running with priority: " + this.getPriority());
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();

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

        // Starting threads
        t1.start();
        t2.start();
        t3.start();
    }
}

class MyThread extends Thread {

public void run() {

System.out.println("Thread running with priority: " + this.getPriority());

}

public class Main {

public static void main(String[] args) {

MyThread t1 = new MyThread();

MyThread t2 = new MyThread();

MyThread t3 = new MyThread();

// Setting priorities

t1.setPriority(Thread.MIN_PRIORITY); // Priority 1

t2.setPriority(Thread.NORM_PRIORITY); // Priority 5

t3.setPriority(Thread.MAX_PRIORITY); // Priority 10

// Starting threads

t1.start();

t2.start();

t3.start();

}

Output Example:

Thread running with priority: 1
Thread running with priority: 5
Thread running with priority: 10

Thread running with priority: 1

Thread running with priority: 5

Thread running with priority: 10

(Note: Actual output order may vary as thread scheduling is system-dependent.)

Thread Priority Scheduling:

Time-Slicing: On most modern systems, threads are scheduled using time-slicing or round-robin techniques. Thread priority may influence how often or how long a thread gets CPU time, but it won’t guarantee that a high-priority thread runs before a lower-priority thread in all cases.
Starvation Risk: If threads with higher priorities are constantly running, threads with lower priorities may suffer from "starvation" and may not get CPU time. This happens more often in systems where strict priority-based scheduling is used.

Important Notes:

Platform Dependent: Thread priorities may behave differently on different operating systems because the JVM relies on the OS’s native thread scheduler.
Use with Care: Over-reliance on thread priority can lead to unexpected behavior, especially in complex, multi-threaded applications. It is best to use it as a hint and not as a strict control mechanism.

Use Cases:

Real-Time Applications: In systems where certain tasks must be executed more urgently, thread priorities can be useful.
Background Tasks: Lowering the priority of background or maintenance tasks ensures that critical tasks receive more CPU time.

New Dev Point

Some problems explained