Filas de tarefas para C++: visão geral de bibliotecas e implementação

Filas de tarefas para C++: guia completo para escolha e implementação

Na programação moderna em C++, o uso eficiente de multithreading é a chave para o desempenho das aplicações. Um dos padrões principais é a fila de tarefas (task queue), que permite distribuir o trabalho entre threads sem gerenciar manualmente seu ciclo de vida. Neste artigo, analisaremos as melhores bibliotecas para C++ que oferecem soluções prontas, além de mostrar como implementar uma fila de tarefas manualmente.

O que é uma fila de tarefas e por que ela é necessária

Uma fila de tarefas é um mecanismo no qual você coloca "tarefas" (funções, lambdas ou objetos) em uma fila, e um pool de threads (thread pool) as executa automaticamente. Isso elimina a necessidade de criar e finalizar threads para cada tarefa, reduz a sobrecarga e simplifica a sincronização.

Principais vantagens:

• Distribuição automática da carga entre os núcleos da CPU
• Reutilização de threads (economia de recursos)
• Facilidade para adicionar novas tarefas sem bloqueios
• Possibilidade de priorização e cancelamento de tarefas

Bibliotecas populares para filas de tarefas em C++

1. Intel Threading Building Blocks (TBB)

Uma das bibliotecas mais poderosas, desenvolvida pela Intel. Oferece tbb::parallel_for, tbb::task_group e um escalonador de tarefas flexível. Adequada para computação de alto desempenho.

#include <tbb/task_group.h>#include <iostream>

int main() {    tbb::task_group tg;    tg.run([] { std::cout << "Tarefa 1"; });    tg.run([] { std::cout << "Tarefa 2"; });    tg.wait(); // aguardar conclusão    return 0;}

2. Boost.Task (obsoleto, mas conceitos vivos no Boost.Fiber)

Antes, o Boost tinha a biblioteca Boost.Task, agora sua funcionalidade foi parcialmente transferida para Boost.Fiber. Permite criar filas com prioridades e resultados assíncronos.

// Exemplo com Boost.Fiber (alternativa moderna)#include <boost/fiber/all.hpp>#include <iostream>

int main() {    boost::fibers::fiber f1([]{        std::cout << "Fiber 1";    });    f1.join();    return 0;}

3. PPL (Parallel Patterns Library) — para Windows

Biblioteca da Microsoft, integrada ao Visual Studio. Usa concurrency::task e concurrency::parallel_for. Integra-se perfeitamente com o Windows Runtime.

#include <ppltasks.h>#include <iostream>

int main() {    concurrency::create_task([]{        std::cout << "Tarefa PPL";    }).wait();    return 0;}

4. QtConcurrent — para projetos Qt

Se você usa Qt, QtConcurrent::run e QThreadPool são uma maneira simples de organizar uma fila de tarefas.

#include <QtConcurrent/QtConcurrentRun>#include <iostream>

int main() {    QtConcurrent::run([]{        std::cout << "Tarefa Qt";    });    QThread::msleep(100);    return 0;}

Implementação de uma fila de tarefas simples com std::thread

Se você não quiser usar bibliotecas externas, pode criar sua própria fila. Abaixo está um exemplo funcional mínimo em C++17.

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

class TaskQueue {public:    explicit TaskQueue(size_t threads) {        for (size_t i = 0; i < threads; ++i) {            workers.emplace_back([this] {                while (true) {                    std::function<void()> task;                    {                        std::unique_lock<std::mutex> lock(mutex);                        condition.wait(lock, [this]