To implement a custom PHP task scheduler, we will focus on creating a simple command-line interface (CLI) application that can execute tasks at specified intervals. We will utilize PHP's built-in functions and demonstrate best practices for scheduling tasks.

Task Scheduler Overview

A task scheduler typically consists of the following components:

  1. Task Definition: The logic that defines what the task does.
  2. Task Registration: The process of registering tasks with the scheduler.
  3. Task Execution: The mechanism by which tasks are executed at their scheduled times.
  4. Task Logging: Keeping track of executed tasks for monitoring and debugging.

Step 1: Define a Task Class

First, we will create a Task class that represents a scheduled task. This class will include properties for the task name, the callable function, and the interval at which it should run.

class Task {
    private $name;
    private $callable;
    private $interval;
    private $lastRun;

    public function __construct(string $name, callable $callable, int $interval) {
        $this->name = $name;
        $this->callable = $callable;
        $this->interval = $interval;
        $this->lastRun = 0;
    }

    public function shouldRun(): bool {
        return (time() - $this->lastRun) >= $this->interval;
    }

    public function run() {
        call_user_func($this->callable);
        $this->lastRun = time();
    }

    public function getName(): string {
        return $this->name;
    }
}

Step 2: Create the Scheduler Class

Next, we will create a TaskScheduler class to manage the tasks. This class will allow us to add tasks and execute them based on their scheduling criteria.

class TaskScheduler {
    private $tasks = [];

    public function addTask(Task $task) {
        $this->tasks[] = $task;
    }

    public function run() {
        foreach ($this->tasks as $task) {
            if ($task->shouldRun()) {
                $task->run();
                echo "Executed task: " . $task->getName() . PHP_EOL;
            }
        }
    }
}

Step 3: Registering Tasks

Now that we have our Task and TaskScheduler classes, we can register tasks. For demonstration purposes, we will create two simple tasks: one for sending emails and another for cleaning up the database.

$scheduler = new TaskScheduler();

$scheduler->addTask(new Task('Send Email', function() {
    echo "Sending email..." . PHP_EOL;
}, 60)); // Runs every 60 seconds

$scheduler->addTask(new Task('Clean Database', function() {
    echo "Cleaning up database..." . PHP_EOL;
}, 120)); // Runs every 120 seconds

Step 4: Running the Scheduler

To run the scheduler, we will create a loop that continuously checks for tasks that need to be executed. In a real-world scenario, this would typically be run as a background process.

while (true) {
    $scheduler->run();
    sleep(1); // Check every second
}

Step 5: Task Logging

For better monitoring, it’s essential to log executed tasks. We can extend the Task class to include logging functionality.

class Task {
    // ... existing properties and methods

    public function run() {
        call_user_func($this->callable);
        $this->logExecution();
        $this->lastRun = time();
    }

    private function logExecution() {
        file_put_contents('task_log.txt', date('Y-m-d H:i:s') . " - Executed task: " . $this->name . PHP_EOL, FILE_APPEND);
    }
}

Conclusion

Creating a custom task scheduler in PHP allows developers to manage background tasks efficiently. By defining tasks, registering them with a scheduler, and executing them based on defined intervals, you can automate various processes in your application. This approach is particularly useful for web applications that require regular maintenance or periodic actions.

Learn more with useful resources

By following this tutorial, you should now have a solid understanding of how to implement a custom task scheduler in PHP, enabling you to automate tasks effectively within your applications.