Planificateur de tâches en C++ : TaskFlow, CronCpp, Boost.Asio

Planificateur de tâches en C++ : Aperçu et exemples d'utilisation

Dans le développement moderne en C++, il est souvent nécessaire d'exécuter certaines actions selon un planning, avec un délai ou de manière périodique. Pour cela, on utilise des planificateurs de tâches (task schedulers). Dans cet article, nous allons examiner trois approches et bibliothèques populaires pour implémenter un planificateur de tâches en C++ : TaskFlow, CronCpp et Boost.Asio. Vous apprendrez comment choisir l'outil adapté à votre projet et verrez des exemples de code.

Pourquoi un planificateur de tâches ?

Un planificateur de tâches permet de :

• Effectuer des opérations en arrière-plan à un moment précis (par exemple, vider le cache à 3h00).
• Lancer des tâches périodiques à un intervalle défini (par exemple, interroger un capteur toutes les 5 secondes).
• Reporter l'exécution d'une tâche à un moment donné.
• Gérer l'exécution parallèle des tâches en tenant compte des dépendances.

1. TaskFlow — un planificateur moderne avec graphe de tâches

TaskFlow est une bibliothèque pour construire des graphes de tâches avec prise en charge de la planification et de l'exécution parallèle. Elle est particulièrement utile lorsque les tâches dépendent les unes des autres et doivent être exécutées dans un ordre spécifique.

Principales fonctionnalités de TaskFlow :

• Construction de graphes orientés acycliques (DAG) de tâches.
• Prise en charge des dépendances conditionnelles et cycliques.
• Répartition automatique des tâches entre les threads.
• Prise en charge intégrée des minuteries et des délais.

Exemple : une tâche simple avec un délai

#include <taskflow/taskflow.hpp>#include <iostream>#include <chrono>

int main() {    tf::Executor executor;    tf::Taskflow taskflow;

    // Création d'une tâche avec un délai de 2 secondes    auto [A, timer] = taskflow.emplace([](){        std::cout << "Tâche A exécutée après 2 secondes" << std::endl;    });

    // Configuration de la minuterie    timer.name("timer");    timer.silent_delay(std::chrono::seconds(2));

    // Lancement du planificateur    executor.run(taskflow).wait();    return 0;}

Ce code crée une tâche qui s'exécutera 2 secondes après le lancement du planificateur. TaskFlow gère automatiquement les threads et le temps.

2. CronCpp — un planificateur léger avec syntaxe cron

CronCpp est une bibliothèque minimaliste pour planifier des tâches selon un planning cron. Elle est idéale si vous devez définir les heures d'exécution dans un format familier (comme dans le cron de Linux).

Principales fonctionnalités de CronCpp :

• Prise en charge de la syntaxe cron standard (minutes, heures, jours, mois, jours de la semaine).
• Légèreté — ne nécessite pas Boost ni d'autres dépendances lourdes.
• API simple pour ajouter et supprimer des tâches.

Exemple : une tâche toutes les minutes

#include <croncpp/croncpp.h>#include <iostream>#include <thread>#include <chrono>

int main() {    cron::Cron cron;        // Ajout d'une tâche qui s'exécute toutes les minutes    cron.schedule("* * * * *", [](){        std::cout << "Tâche exécutée toutes les minutes !" << std::endl;    });

    // Lancement du planificateur dans un thread d'arrière-plan    std::thread cron_thread([&cron](){        cron.start();    });

    // Laissez-le fonctionner pendant 5 minutes    std::this_thread::sleep_for(std::chrono::minutes(5));        cron.stop();    cron_thread.join();    return 0;}

Dans cet exemple, la tâche s'exécutera toutes les minutes. CronCpp calcule automatiquement l'heure du prochain lancement et appelle la fonction.

3. Boost.Asio — un planificateur puissant pour les tâches asynchrones

Boost.Asio n'est pas seulement un planificateur, mais une bibliothèque complète pour la programmation asynchrone. Ses minuteries et planificateurs de tâches sont largement