How to Use a PriorityQueue to Implement a Priority-Based Task Scheduler in Java? - Coding

In Java, the PriorityQueue data structure offers an efficient way to manage tasks based on their assigned priorities. Elements with higher priority are dequeued before elements with lower priority. It uses a heap data structure internally to maintain the ordering of elements.

In this article, we will learn how to use a PriorityQueue to implement a priority-based task scheduler in Java.

Step-by-Step Implementation to Use a PriorityQueue to Implement a Priority-based Task Scheduler

Below are the steps to implement a Priority-based Task Scheduler.

Step 1: Define the Task Class

public class Task {
    private String description;
    private int priority; // Lower values mean higher priority
    private Object data; // Any data needed for execution
    // Getters, setters, and a constructor
}

Step 2: Create the PriorityQueue

PriorityQueue<Task> queue = new PriorityQueue<>(10, new TaskComparator());

Step 3: Implement the TaskComparator (if necessary)

public class TaskComparator implements Comparator<Task> {
    @Override
    public int compare(Task t1, Task t2) {
        return Integer.compare(t1.getPriority(), t2.getPriority());
    }
}

Step 4: Schedule Tasks

Task task1 = new Task("Download files", 1, ...);
Task task2 = new Task("Send report", 2, ...);
queue.add(task1);
queue.add(task2);

Step 5: Execute Tasks

while (!queue.isEmpty()) {
    Task currentTask = queue.poll(); // Removes and returns the highest-priority task
    // Execute the task using currentTask.data or other relevant information
    System.out.println("Executing task: " + currentTask.getDescription());
}

Program to Implement a Priority-based Task Scheduler in Java

Java

import java.util.PriorityQueue; 
  
// Task class representing a task with a priority 
class Task implements Comparable<Task> { 
    private String name; 
    private int priority; 
  
    // Constructor to initialize task name and priority 
    public Task(String name, int priority) { 
        this.name = name; 
        this.priority = priority; 
    } 
  
    // Getter method for task name 
    public String getName() { 
        return name; 
    } 
  
    // Getter method for task priority 
    public int getPriority() { 
        return priority; 
    } 
  
    // Implementation of compareTo method from Comparable interface 
    // Allows tasks to be compared based on their priority 
    @Override
    public int compareTo(Task other) { 
        return Integer.compare(this.priority, other.priority); 
    } 
  
    // Override toString method for better task representation 
    @Override
    public String toString() { 
        return "Task{" + 
                "name='" + name + '\'' + 
                ", priority=" + priority + 
                '}'; 
    } 
} 
  
// TaskScheduler class implementing priority-based task scheduling 
class TaskScheduler  
{ 
    private PriorityQueue<Task> taskQueue; 
  
    // Constructor to initialize PriorityQueue for task scheduling 
    public TaskScheduler()  
    { 
        // Initialize the priority queue with a comparator for task priority 
        taskQueue = new PriorityQueue<>(); 
    } 
  
    // Method to add a new task to the scheduler 
    public void addTask(Task task) { 
        taskQueue.offer(task); // Adds task to the priority queue 
    } 
  
    // Method to retrieve and execute the highest priority task 
    public void executeNextTask() { 
        Task task = taskQueue.poll(); // retrieves and removes the highest priority task 
        if (task != null) { 
            System.out.println("Executing task: " + task.getName());  
        } else { 
            System.out.println("No tasks left to execute.");  
        } 
    } 
} 
  
// main class demonstrating the usage of TaskScheduler 
public class PriorityTaskSchedulerExample { 
    public static void main(String[] args) { 
        TaskScheduler scheduler = new TaskScheduler(); // creates an instance of TaskScheduler 
  
        // adding tasks with different priorities 
        scheduler.addTask(new Task("Task 1", 3)); 
        scheduler.addTask(new Task("Task 2", 1)); 
        scheduler.addTask(new Task("Task 3", 2)); 
  
        // executing tasks in priority order 
        scheduler.executeNextTask(); // Task 2 (highest priority) 
        scheduler.executeNextTask(); // Task 3 
        scheduler.executeNextTask(); // Task 1 
        scheduler.executeNextTask(); // No tasks left 
    } 
} 

Output

Executing task: Task 2
Executing task: Task 3
Executing task: Task 1
No tasks left to execute.

Explanation of the above code:

1. Task Class:

Represents a task with a name and priority (lower value means higher priority).
Implements Comparable<Task> for comparison based on priority using compareTo.
Defines toString for a clear string representation of the task.

2. TaskScheduler Class:

Holds a PriorityQueue<Task> to manage tasks based on their priority.
Provides methods to:
- Add tasks using addTask(Task task).
- Execute the highest priority task using executeNextTask(). This removes the task from the queue and prints its name.

3. PriorityTaskSchedulerExample (Main Class):

Creates a TaskScheduler instance.
Adds three tasks with different priorities.
Executes tasks repeatedly using executeNextTask() until the queue is empty.

Reffered: https://www.geeksforgeeks.org

Java

Related
How to Use the ExecutorService.invokeAny Method in Java?
How to Make a Java Thread Sleep for a Specific Duration?
How to Create a Synchronized HashTable in Java?
How to Handle SQLException in JDBC?
How to do Method Overloading for Null Argument?

Type:	Geek
Category:	Coding
Sub Category:	Tutorial
Uploaded by:	Admin
Views:	17