0Pricing
C++ Academy · Leçon

Bases de std::async et std::future

Exécuter des tâches de manière asynchrone et récupérer leurs résultats via std::future

Bases de std::async et std::future est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Tâches asynchrones

std::async exécute une fonction de manière asynchrone et renvoie un std::future qui fournit le résultat. Il s’agit d’une solution de plus haut niveau que la gestion manuelle des fils d’exécution.

Utilisation de base

Passez une fonction appelable et ses arguments. std::async renvoie un std::future<Result>.

#include <future>

int compute() { return 42; }

std::future<int> f = std::async(compute);
int result = f.get();   // blocks until done

Politiques de lancement

Le premier argument contrôle le moment où la tâche s’exécute :

  • std::launch::async — démarre immédiatement un nouveau fil d’exécution
  • std::launch::deferred — s’exécute de manière synchrone lors de l’appel à get()
  • Par défaut (aucune politique) — l’implémentation choisit
auto f = std::async(std::launch::async, compute);

Méthodes de std::future

Opérations courantes :

  • get() — bloque jusqu’à la fin et renvoie le résultat, une seule fois
  • wait() — bloque sans renvoyer le résultat
  • wait_for(d) / wait_until(t) — attentes temporisées
  • valid() — ce futur a-t-il été configuré ?

Propagation des exceptions

Si la tâche asynchrone lève une exception, celle-ci est stockée dans le futur puis relancée lors de l’appel à get().

auto f = std::async([] { throw std::runtime_error("oops"); });
try {
    f.get();
} catch (const std::exception& e) {
    std::cout << e.what();
}

Renvoyer plusieurs valeurs

Encapsulez le résultat dans un tuple, une structure ou un conteneur.

auto f = std::async([] {
    return std::make_pair(42, std::string("hello"));
});
auto [n, s] = f.get();

Plusieurs tâches en parallèle

Lancez plusieurs tâches asynchrones et attendez qu’elles soient toutes terminées.

auto a = std::async(work_a);
auto b = std::async(work_b);
auto c = std::async(work_c);

std::cout << a.get() + b.get() + c.get();

std::promise : futur manuel

Pour les modèles producteur-consommateur où le consommateur a besoin d’un futur alors que le producteur se trouve dans un autre fil d’exécution, utilisez std::promise.

std::promise<int> p;
std::future<int> f = p.get_future();

std::thread t([&p] { p.set_value(42); });
std::cout << f.get();
t.join();

std::packaged_task

Associe une fonction appelable à un futur. Utile lorsque la tâche est appelée ailleurs, par exemple dans un groupe de fils d’exécution.

shared_future

Un std::future ne peut être lu qu’une seule fois. std::shared_future permet plusieurs lectures, ce qui est utile pour diffuser un résultat.

Comportement du destructeur

Le destructeur d’un futur renvoyé par std::async avec la politique par défaut peut bloquer jusqu’à la fin de la tâche. Soyez vigilant avec les tâches de longue durée.

Au-delà de std::async

Pour une programmation asynchrone adaptée à la production, envisagez des bibliothèques comme Boost.Asio, Folly ou les exécuteurs et les coroutines de C++20/23. std::async constitue un point de départ.

Vérification rapide

Que fait l’appel à .get() sur un std::future ?

Récapitulatif

std::async exécute une fonction de manière asynchrone ; le std::future renvoyé fournit le résultat et propage les exceptions. Utilisez les politiques de lancement pour contrôler l’exécution. Pour les modèles complexes, utilisez std::promise et std::packaged_task.

Questions Fréquemment Posées

La leçon « Bases de std::async et std::future » est-elle gratuite ?

Oui — le texte complet de « Bases de std::async et std::future » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Bases de std::async et std::future » ?

Exécuter des tâches de manière asynchrone et récupérer leurs résultats via std::future Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Bases de std::async et std::future » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. std::thread : jonction et détachement
  2. std::mutex, lock_guard et unique_lock
  3. Variables de condition et schémas de travailleurs
  4. Bases de std::async et std::future
← Retour à C++ Academy