What is a Task Scheduler?

A Task Scheduler is a system that manages the execution of tasks at predefined times or intervals. It is commonly used in operating systems, distributed systems, and backend services to automate jobs like backups, notifications, report generation, and periodic cleanup tasks.

For example, a task might be scheduled to run once at 8:00 AM, every day at midnight, or 5 minutes after another task completes.

Loading simulation...

The scheduler must ensure these tasks run reliably and at the correct times, even under heavy load or failures.

In this chapter, we will explore the low-level design of a Task Scheduler.

There are multiple variants to this problem which you can find in the concurrency interview course:

Let’s start by clarifying the requirements:

1. Clarifying Requirements

Before starting the design, it's important to ask thoughtful questions to uncover hidden assumptions and better define the scope of the system.

Here is an example of how a conversation between the candidate and the interviewer might unfold:

Discussion

Candidate: "Should the scheduler support only one-time tasks, or recurring tasks as well?"

Interviewer: "Both. One-time tasks run at a specific future time, and recurring tasks run repeatedly at a fixed interval."

Candidate: "Should tasks be executed exactly on time, or is a small delay acceptable?"

Interviewer: "A small delay is acceptable. We're not aiming for real-time precision, but tasks should execute as close as possible to the scheduled time. "

Candidate: "Should the scheduler support retries if a task fails?"

Interviewer: "No retries for now. However, you can keep the design open to supporting retries later."

Candidate: "Can a task have dependencies, such that one task should only start after another completes?"

Interviewer: "Let's not handle task dependencies in this version. All tasks are independent."

Candidate: "What should happen if a task throws an exception during execution?"

Interviewer: "The exception should be caught and reported, but it should not crash the worker thread or block other tasks."

Candidate: "Can multiple tasks run in parallel?"

Interviewer: "Yes. The system should be able to run multiple tasks concurrently using a configurable number of worker threads."

Candidate: "Should we support task cancellation?"

Interviewer: "Yes, a scheduled task should be cancellable before it executes."

After gathering the details, we can summarize the key system requirements.

1.1 Functional Requirements

The system should schedule one-time tasks to run at a specific future time
The system should schedule recurring tasks to run repeatedly at a fixed interval
The system should execute tasks concurrently using a configurable number of worker threads
The system should allow cancelling a scheduled task before it executes
The system should notify observers when tasks start, complete, or fail
The system should track task status through its lifecycle

1.2 Non-Functional Requirements

The design should follow object-oriented principles with clear separation of concerns
The system should be thread-safe for concurrent scheduling and execution
The system should be extensible to support new scheduling strategies without modifying existing code
The components should be testable in isolation

2. Core Entities and Classes

Premium Content

This content is for premium members only.

Design a Task Scheduler