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.