Files d'attente de tâches pour C++ : aperçu des bibliothèques et implémentation

Files d'attente de tâches pour C++ : guide complet pour le choix et l'implémentation

Dans la programmation moderne en C++, l'utilisation efficace du multithreading est la clé de la performance des applications. L'un des modèles clés est la file d'attente de tâches (task queue), qui permet de répartir le travail entre les threads sans gestion manuelle de leur cycle de vie. Dans cet article, nous analyserons les meilleures bibliothèques pour C++ offrant des solutions prêtes à l'emploi, et montrerons également comment implémenter une file d'attente de tâches vous-même.

Qu'est-ce qu'une file d'attente de tâches et pourquoi en a-t-on besoin

Une file d'attente de tâches est un mécanisme où vous placez dans une file d'attente des « tâches » (fonctions, lambdas ou objets), et un pool de threads (thread pool) les exécute automatiquement. Cela évite de devoir créer et terminer des threads pour chaque tâche, réduit les frais généraux et simplifie la synchronisation.

Principaux avantages :

• Répartition automatique de la charge entre les cœurs du CPU
• Réutilisation des threads (économie de ressources)
• Simplicité d'ajout de nouvelles tâches sans blocages
• Possibilité de priorisation et d'annulation des tâches

Bibliothèques populaires pour les files d'attente de tâches en C++

1. Intel Threading Building Blocks (TBB)

L'une des bibliothèques les plus puissantes, développée par Intel. Elle fournit tbb::parallel_for, tbb::task_group et un planificateur de tâches flexible. Adaptée aux calculs haute performance.

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

int main() {    tbb::task_group tg;    tg.run([] { std::cout << "Tâche 1"; });    tg.run([] { std::cout << "Tâche 2"; });    tg.wait(); // attendre la fin    return 0;}

2. Boost.Task (obsolète, mais les concepts perdurent dans Boost.Fiber)

Auparavant, Boost avait la bibliothèque Boost.Task, dont les fonctionnalités ont été partiellement transférées à Boost.Fiber. Elle permet de créer des files d'attente avec priorités et résultats asynchrones.

// Exemple avec Boost.Fiber (alternative moderne)#include <boost/fiber/all.hpp>#include <iostream>

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

3. PPL (Parallel Patterns Library) — pour Windows

Bibliothèque de Microsoft, intégrée dans Visual Studio. Elle utilise concurrency::task et concurrency::parallel_for. S'intègre parfaitement avec Windows Runtime.

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

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

4. QtConcurrent — pour les projets Qt

Si vous utilisez Qt, QtConcurrent::run et QThreadPool sont un moyen simple d'organiser une file d'attente de tâches.

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

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

Implémentation d'une file d'attente de tâches simple avec std::thread

Si vous ne souhaitez pas utiliser de bibliothèques externes, vous pouvez écrire votre propre file d'attente. Voici un exemple fonctionnel minimal en 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]