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.
How to Use a PriorityQueue to Implement a Priority-Based Task Scheduler in Java?
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());
}
Contact Us