Programmation asynchrone en C++ : guide complet avec exemples

Programmation asynchrone en C++ : de std::async aux coroutines

La programmation asynchrone en C++ est un outil puissant pour créer des applications hautes performances et réactives. Dans le monde moderne, où les processeurs multicœurs sont devenus la norme, savoir gérer efficacement les tâches parallèles est une compétence essentielle pour tout développeur C++. Dans cet article, nous allons décortiquer les concepts clés, en commençant par les mécanismes de base de la bibliothèque standard et en terminant par les coroutines modernes de C++20.

Pourquoi la programmation asynchrone est-elle nécessaire ?

L'objectif principal de la programmation asynchrone est de ne pas bloquer le thread principal d'exécution du programme. Imaginez que votre application doive télécharger un fichier depuis le réseau, le traiter et l'afficher à l'utilisateur. Si vous effectuez ces opérations de manière synchrone, l'interface "se bloquera" pendant le téléchargement. L'approche asynchrone permet de lancer une opération longue "en arrière-plan", tandis que le thread principal continue de traiter les entrées utilisateur.

Les principales approches de l'asynchrone en C++

Il existe plusieurs façons d'implémenter l'exécution asynchrone en C++ :

• Gestion manuelle des threads (std::thread) — une approche de bas niveau mais flexible.
• std::async et std::future — un mécanisme de haut niveau pour lancer des tâches asynchrones.
• std::packaged_task et std::promise — pour un contrôle plus fin.
• Les coroutines (C++20) — une manière moderne et élégante d'écrire du code asynchrone.

Utilisation de std::async et std::future

C'est la façon la plus simple de lancer une tâche asynchrone. La fonction std::async retourne un objet std::future qui contiendra le résultat de l'exécution.

#include <iostream>#include <future>#include <thread>#include <chrono>

int heavy_computation(int x) {    std::this_thread::sleep_for(std::chrono::seconds(2));    return x * x;}

int main() {    std::cout << "Lancement de la tâche asynchrone...";    std::future<int> result = std::async(std::launch::async, heavy_computation, 42);        // Faire autre chose pendant que la tâche s'exécute    std::cout << "Le thread principal n'est pas bloqué !";        // Récupérer le résultat (bloque si la tâche n'est pas encore terminée)    int value = result.get();    std::cout << "Résultat : " << value << "";    return 0;}

Le drapeau std::launch::async garantit que la tâche sera exécutée dans un thread séparé. S'il n'est pas spécifié, l'implémentation peut différer l'exécution jusqu'à l'appel de .get().

Travailler avec std::promise et std::packaged_task

Ces mécanismes offrent plus de contrôle. std::promise permet de "promettre" une valeur qui sera définie plus tard, tandis que std::packaged_task encapsule un objet appelable dans une tâche.

#include <iostream>#include <future>#include <thread>

void set_value(std::promise<int>&& prom) {    std::this_thread::sleep_for(std::chrono::seconds(1));    prom.set_value(100);}

int main() {    std::promise<int> prom;    std::future<int> fut = prom.get_future();        std::thread t(set_value, std::move(prom));        std::cout << "Attente du résultat...";    int value = fut.get();    std::cout << "Reçu : " << value << "";        t.join();    return 0;}

Important : std::promise et std::future sont des objets déplaçables uniquement (move-only). Ils ne peuvent pas être copiés, seulement déplacés.

Les coroutines en C++20 : un nouveau niveau d'asynchrone

Les coroutines (coroutines) sont des fonctions qui peuvent suspendre leur exécution et la reprendre plus tard. Elles permettent d'écrire du code asynchrone comme s'il était synchrone.

Base