Colas de tareas para C++: revisión de bibliotecas e implementación

Colas de tareas para C++: de lo simple a lo complejo

La cola de tareas (Task Queue) es uno de los patrones clave de la programación multihilo. Permite organizar la ejecución asíncrona del trabajo: uno o varios hilos productores añaden tareas, y un grupo de hilos trabajadores las procesan. En C++ existen tanto herramientas estándar como bibliotecas especializadas para esto.

1. Cola estándar: std::queue con bloqueos

La opción más simple es usar std::queue junto con un mutex y una variable de condición. Esto es adecuado para proyectos pequeños donde la sobrecarga de sincronización no es crítica.

#include <queue>#include <mutex>#include <condition_variable>

template<typename T>class ThreadSafeQueue {    std::queue<T> q_;    mutable std::mutex mtx_;    std::condition_variable cv_;public:    void push(T value) {        std::lock_guard<std::mutex> lock(mtx_);        q_.push(std::move(value));        cv_.notify_one();    }

    T pop() {        std::unique_lock<std::mutex> lock(mtx_);        cv_.wait(lock, [this]{ return !q_.empty(); });        T val = std::move(q_.front());        q_.pop();        return val;    }};

Ventajas: simplicidad, incluido en la biblioteca estándar.
Desventajas: bloqueos en cada operación, posible contención e inversión de prioridades.

2. boost::lockfree::queue — cola libre de bloqueos

La biblioteca Boost proporciona estructuras de datos libres de bloqueos basadas en operaciones CAS. boost::lockfree::queue es una cola multihilo sin bloqueos que utiliza un pool de memoria fijo o dinámico.

#include <boost/lockfree/queue.hpp>

boost::lockfree::queue<int> queue(128); // tamaño fijo

void producer() {    for (int i = 0; i < 1000; ++i) {        while (!queue.push(i)) {            // si la cola está llena, esperamos o descartamos        }    }}

void consumer() {    int value;    while (queue.pop(value)) {        process(value);    }}

Ventajas: alto rendimiento con colas pequeñas, ausencia de bloqueos.
Desventajas: complejidad de depuración, tamaño limitado (para la versión fija), necesidad de recuperación de memoria.

3. Intel TBB (Threading Building Blocks) — tbb::concurrent_queue

Intel TBB es una biblioteca industrial para programación paralela. Sus tbb::concurrent_queue (y tbb::concurrent_bounded_queue) están optimizadas para alta carga.

#include <tbb/concurrent_queue.h>

tbb::concurrent_bounded_queue<Task> task_queue;task_queue.set_capacity(1024); // limitamos el tamaño

// Productortask_queue.push(std::move(task));

// ConsumidorTask t;if (task_queue.try_pop(t)) {    t.execute();}

Ventajas: excelente escalabilidad, soporte de modos acotado/no acotado, integración con el planificador de tareas de TBB.
Desventajas: licencia Apache 2.0 (anteriormente GPL), dependencia de toda la biblioteca TBB.

4. libdispatch (Grand Central Dispatch) mediante binding de C++

GCD es un sistema de gestión de colas de Apple, disponible en macOS/iOS. Para C++ existe el envoltorio dispatch/queue. En Linux se puede usar libdispatch (código abierto).

#include <dispatch/dispatch.h>

dispatch_queue_t queue = dispatch_queue_create("com.example.myqueue", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(queue, ^{    // tarea 1});

dispatch_async(queue, ^{    // tarea 2});

dispatch_release(queue);

Ventajas: gestión eficiente de hilos, escalado automático al número de núcleos.
Desventajas: limitada