Implement a thread-safe periodic job scheduler

Problem: Periodic Job Scheduler (Concurrency)

Implement a small in-process job scheduler that can run periodic tasks (functions/callbacks) at a target frequency.

Requirements

1. You must support scheduling tasks specified as a function/callback.
2. Each task is periodic, e.g. 50 Hz (50 times per second). You must convert frequency to a period (time interval).
3. Expose two thread-safe APIs:

• schedule(taskFn, frequencyHz) -> jobId
• cancel(jobId) -> void

1. The implementation must be runnable (not just a dry run):

• There is at least one dedicated worker thread responsible for executing the tasks.
• Another thread may call schedule() and cancel() concurrently while the worker is running.

Behavioral expectations / assumptions (state clearly in your implementation)

• Use a monotonic clock for timing.
• Multiple jobs may be scheduled at once.
• If a job is cancelled, it should not run again after cancellation takes effect.
• Define what happens if a task execution takes longer than its period (e.g., skip missed ticks vs. run immediately to “catch up”).

What to provide

• The scheduler data structures and synchronization strategy.
• The worker thread loop logic (sleep/wake strategy).
• How cancellation is handled safely under concurrency.

Clarifying Questions to Ask

• Clarify language/runtime assumptions and the level of depth expected.
• Use examples to connect definitions to practical engineering decisions.
• Call out pitfalls, trade-offs, and common misconceptions.