Planificador de tareas en C++: creación y gestión de tareas

Planificador de tareas en C++: guía completa

El planificador de tareas (Task Scheduler) es una herramienta potente que permite automatizar la ejecución de código en momentos específicos o con una periodicidad determinada. En C++, la implementación de dicho planificador requiere comprender el multihilo, la sincronización y el trabajo con intervalos de tiempo. En este artículo, analizaremos cómo crear su propio planificador de tareas desde cero, utilizando la biblioteca estándar de C++ (C++11 y posteriores).

Componentes principales del planificador

Cualquier planificador de tareas consta de varios elementos clave:

• Almacenamiento de tareas — una cola o contenedor para almacenar las tareas planificadas.
• Temporizador — un mecanismo que determina cuándo debe ejecutarse una tarea.
• Grupo de hilos — para la ejecución paralela de tareas sin bloquear el hilo principal.
• Mecanismo de cancelación — la posibilidad de cancelar una tarea antes de su ejecución.

Implementación simple de un planificador con un solo hilo

Comencemos con un ejemplo básico donde las tareas se ejecutan secuencialmente en un hilo en segundo plano:

#include <iostream>#include <thread>#include <chrono>#include <functional>#include <queue>#include <mutex>#include <condition_variable>

class TaskScheduler {public:    // Programa una tarea con un retraso    void schedule(std::function<void()> task, int delay_ms) {        std::lock_guard<std::mutex> lock(mutex_);        tasks_.push({std::chrono::steady_clock::now() +                      std::chrono::milliseconds(delay_ms), task});        cv_.notify_one();    }

    // Inicia el planificador en un hilo separado    void start() {        worker_ = std::thread([this]() {            while (!stop_) {                std::unique_lock<std::mutex> lock(mutex_);                if (tasks_.empty()) {                    cv_.wait(lock, [this]() {                         return !tasks_.empty() || stop_;                     });                }                if (stop_) break;

                auto now = std::chrono::steady_clock::now();                auto& top = tasks_.top();                if (top.time <= now) {                    auto task = top.task;                    tasks_.pop();                    lock.unlock();                    task(); // Ejecuta la tarea                } else {                    cv_.wait_until(lock, top.time);                }            }        });    }

    void stop() {        stop_ = true;        cv_.notify_all();        if (worker_.joinable()) worker_.join();    }

private:    struct Task {        std::chrono::steady_clock::time_point time;        std::function<void()> task;        bool operator>(const Task& other) const {            return time > other.time;        }    };

    std::priority_queue<Task, std::vector<Task>, std::greater<Task>> tasks_;    std::mutex mutex_;    std::condition_variable cv_;    std::thread worker_;    bool stop_ = false;};

int main() {    TaskScheduler scheduler;    scheduler.start();

    scheduler.schedule([]() {        std::cout << "Tarea 1 ejecutada después de 2 segundos";    }, 2000);

    scheduler.schedule([]() {        std::cout << "Tarea 2 ejecutada después de 1 segundo";    }, 1000);

    std::this_thread::sleep_for(std::chrono::seconds(3));    scheduler.stop();    return 0;}

Planificador con grupo de hilos para ejecución paralela

Para escenarios más complejos, donde las tareas pueden tardar mucho en ejecutarse, es mejor utilizar un grupo de hilos. Aquí hay un ejemplo con un grupo mínimo:

#include <vector>#include <queue>#include <thread>#include <mutex>#include <condition_variable>#include <f