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

Files d'attente de tâches pour C++ : du simple au complexe

La file d'attente de tâches (Task Queue) est l'un des modèles clés de la programmation multithread. Elle permet d'organiser l'exécution asynchrone du travail : un ou plusieurs threads producteurs ajoutent des tâches, tandis qu'un pool de threads de travail les traite. En C++, il existe à la fois des outils standard et des bibliothèques spécialisées pour cela.

1. File d'attente standard : std::queue avec verrous

L'option la plus simple consiste à utiliser std::queue avec un mutex et une variable conditionnelle. Cela convient aux petits projets où les frais généraux de synchronisation ne sont pas critiques.

#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;    }};

Avantages : simplicité, intégré à la bibliothèque standard.
Inconvénients : verrous sur chaque opération, contention possible et inversion de priorité.

2. boost::lockfree::queue — file d'attente sans verrou

La bibliothèque Boost fournit des structures de données sans verrou basées sur des opérations CAS. boost::lockfree::queue est une file d'attente multithread sans verrous, utilisant un pool de mémoire fixe ou dynamique.

#include <boost/lockfree/queue.hpp>

boost::lockfree::queue<int> queue(128); // taille fixe

void producer() {    for (int i = 0; i < 1000; ++i) {        while (!queue.push(i)) {            // si la file est pleine, attendre ou ignorer        }    }}

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

Avantages : haute performance pour les petites files d'attente, absence de verrous.
Inconvénients : complexité de débogage, taille limitée (pour la version fixe), nécessité de récupération de mémoire.

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

Intel TBB est une bibliothèque industrielle pour la programmation parallèle. Ses tbb::concurrent_queue (et tbb::concurrent_bounded_queue) sont optimisées pour les charges élevées.

#include <tbb/concurrent_queue.h>

tbb::concurrent_bounded_queue<Task> task_queue;task_queue.set_capacity(1024); // limiter la taille

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

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

Avantages : excellente évolutivité, prise en charge des modes borné/non borné, intégration avec le planificateur de tâches TBB.
Inconvénients : licence Apache 2.0 (auparavant GPL), dépendance à l'ensemble de la bibliothèque TBB.

4. libdispatch (Grand Central Dispatch) via le binding C++

GCD est un système de gestion de files d'attente d'Apple, disponible sur macOS/iOS. Pour C++, il existe une enveloppe dispatch/queue. Sous Linux, on peut utiliser libdispatch (opensource).

#include <dispatch/dispatch.h>

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

dispatch_async(queue, ^{    // tâche 1});

dispatch_async(queue, ^{    // tâche 2});

dispatch_release(queue);

Avantages : gestion efficace des threads, mise à l'échelle automatique en fonction du nombre de cœurs.
Inconvénients : limitée