Planejador de Tarefas em C++: TaskFlow, CronCpp, Boost.Asio

Planejador de Tarefas em C++: Visão Geral e Exemplos de Uso

No desenvolvimento moderno em C++, surge frequentemente a necessidade de executar determinadas ações de acordo com um agendamento, com atraso ou periodicamente. Para isso, são utilizados planejadores de tarefas (task schedulers). Neste artigo, veremos três abordagens e bibliotecas populares para implementar um planejador de tarefas em C++: TaskFlow, CronCpp e Boost.Asio. Você aprenderá como escolher a ferramenta adequada para o seu projeto e verá exemplos de código.

Por que preciso de um planejador de tarefas?

Um planejador de tarefas permite:

• Executar operações em segundo plano em um horário específico (por exemplo, limpeza de cache às 3:00).
• Iniciar tarefas periódicas com um intervalo definido (por exemplo, consultar um sensor a cada 5 segundos).
• Adiar a execução de uma tarefa por um determinado período.
• Gerenciar a execução paralela de tarefas considerando dependências.

1. TaskFlow — planejador moderno com grafo de tarefas

TaskFlow é uma biblioteca para construir grafos de tarefas com suporte a planejamento e execução paralela. Ela é especialmente útil quando as tarefas dependem umas das outras e precisam ser executadas em uma ordem específica.

Principais recursos do TaskFlow:

• Construção de grafos acíclicos direcionados (DAG) de tarefas.
• Suporte a dependências condicionais e cíclicas.
• Distribuição automática de tarefas entre threads.
• Suporte integrado para temporizadores e atrasos.

Exemplo: tarefa simples com atraso

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

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

    // Criamos uma tarefa com atraso de 2 segundos    auto [A, timer] = taskflow.emplace([](){        std::cout << "Tarefa A executada após 2 segundos" << std::endl;    });

    // Configuramos o temporizador    timer.name("timer");    timer.silent_delay(std::chrono::seconds(2));

    // Iniciamos o planejador    executor.run(taskflow).wait();    return 0;}

Este código cria uma tarefa que será executada 2 segundos após o início do planejador. O TaskFlow gerencia automaticamente as threads e o tempo.

2. CronCpp — planejador leve com sintaxe cron

CronCpp é uma biblioteca minimalista para agendar tarefas usando a sintaxe cron. Ela é ideal se você precisa definir horários de execução no formato familiar (como no cron do Linux).

Principais recursos do CronCpp:

• Suporte à sintaxe cron padrão (minutos, horas, dias, meses, dias da semana).
• Leve — não requer Boost ou outras dependências pesadas.
• API simples para adicionar e remover tarefas.

Exemplo: tarefa a cada minuto

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

int main() {    cron::Cron cron;        // Adicionamos uma tarefa que é executada a cada minuto    cron.schedule("* * * * *", [](){        std::cout << "Tarefa executada a cada minuto!" << std::endl;    });

    // Iniciamos o planejador em uma thread em segundo plano    std::thread cron_thread([&cron](){        cron.start();    });

    // Deixamos funcionar por 5 minutos    std::this_thread::sleep_for(std::chrono::minutes(5));        cron.stop();    cron_thread.join();    return 0;}

Neste exemplo, a tarefa será executada a cada minuto. O CronCpp calcula automaticamente o horário da próxima execução e chama a função.

3. Boost.Asio — planejador poderoso para tarefas assíncronas

Boost.Asio não é apenas um planejador, mas uma biblioteca completa para programação assíncrona. Seus temporizadores e planejadores de tarefas são amplamente