Java Thread setPriority() Method

The Thread.setPriority() method in Java is used to set the priority of a thread.

Table of Contents

1. Introduction
2. setPriority() Method Syntax
3. Thread Priority Levels
4. Examples
   • Basic Usage
   • Setting Thread Priority in Multi-threaded Environment
5. Real-World Use Case
6. Conclusion

Introduction

The Thread.setPriority() method allows you to set the priority of a thread. Thread priorities are used by the thread scheduler to decide when each thread should run. Higher priority threads are more likely to be executed before lower priority threads.

setPriority() Method Syntax

The syntax for the setPriority() method is as follows:

public final void setPriority(int newPriority)

Parameters:

• newPriority: The new priority for the thread.

Throws:

• IllegalArgumentException if the priority is not in the range Thread.MIN_PRIORITY (1) to Thread.MAX_PRIORITY (10).
• SecurityException if the current thread cannot modify this thread.

Thread Priority Levels

Java defines three priority levels:

• Thread.MIN_PRIORITY (constant 1) - Minimum priority.
• Thread.NORM_PRIORITY (constant 5) - Normal priority (default).
• Thread.MAX_PRIORITY (constant 10) - Maximum priority.

Examples

Basic Usage

To demonstrate the basic usage of setPriority(), we will create a thread and set its priority.

Example

public class SetPriorityExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running with priority: " + Thread.currentThread().getPriority());
        });

        thread.setPriority(Thread.MAX_PRIORITY);
        thread.start();

        try {
            thread.join(); // Wait for the thread to finish
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        System.out.println("Main thread resumes after thread completion.");
    }
}

Output:

Thread is running with priority: 10
Main thread resumes after thread completion.

Setting Thread Priority in Multi-threaded Environment

In a multi-threaded environment, you can set different priorities for different threads to control their execution order.

Example

public class MultiThreadPriorityExample {
    public static void main(String[] args) {
        Runnable lowPriorityTask = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Low priority task running...");
                try {
                    Thread.sleep(500); // Simulate work
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        Runnable highPriorityTask = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("High priority task running...");
                try {
                    Thread.sleep(500); // Simulate work
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        Thread lowPriorityThread = new Thread(lowPriorityTask);
        lowPriorityThread.setPriority(Thread.MIN_PRIORITY);

        Thread highPriorityThread = new Thread(highPriorityTask);
        highPriorityThread.setPriority(Thread.MAX_PRIORITY);

        lowPriorityThread.start();
        highPriorityThread.start();

        try {
            lowPriorityThread.join(); // Wait for low priority thread to finish
            highPriorityThread.join(); // Wait for high priority thread to finish
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        System.out.println("Main thread resumes after all threads completion.");
    }
}

Output:

High priority task running...
Low priority task running...
High priority task running...
Low priority task running...
High priority task running...
Low priority task running...
High priority task running...
Low priority task running...
High priority task running...
Low priority task running...
Main thread resumes after all threads completion.

(Note: The exact order of output lines may vary due to the nature of multi-threading and thread scheduling.)

Real-World Use Case

Prioritizing Critical Tasks

In real-world scenarios, thread priorities can be used to prioritize critical tasks over less critical ones. For example, in a server application, you might want to prioritize threads handling high-priority requests over those handling background maintenance tasks.

Example

public class ServerApplicationExample {
    public static void main(String[] args) {
        Runnable highPriorityTask = () -> {
            System.out.println("Handling high-priority request...");
            try {
                Thread.sleep(2000); // Simulate request processing
                System.out.println("High-priority request handled.");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };

        Runnable lowPriorityTask = () -> {
            System.out.println("Performing background maintenance...");
            try {
                Thread.sleep(3000); // Simulate maintenance work
                System.out.println("Background maintenance completed.");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };

        Thread highPriorityThread = new Thread(highPriorityTask);
        highPriorityThread.setPriority(Thread.MAX_PRIORITY);

        Thread lowPriorityThread = new Thread(lowPriorityTask);
        lowPriorityThread.setPriority(Thread.MIN_PRIORITY);

        highPriorityThread.start();
        lowPriorityThread.start();

        try {
            highPriorityThread.join(); // Wait for high priority thread to finish
            lowPriorityThread.join(); // Wait for low priority thread to finish
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        System.out.println("Main thread resumes after all tasks completion.");
    }
}

Output:

Handling high-priority request...
Performing background maintenance...
High-priority request handled.
Background maintenance completed.
Main thread resumes after all tasks completion.

Conclusion

The Thread.setPriority() method in Java provides a way to set the priority of a thread, influencing the order in which threads are scheduled for execution. By understanding how to use this method, you can manage thread priorities effectively and ensure that critical tasks are given appropriate execution precedence in your Java applications. Whether you are working with single-threaded or multi-threaded environments, the setPriority() method offers a valuable tool for controlling thread behavior and performance.