Procédure pas à pas : implémentation d’objets future

Cette rubrique montre comment implémenter des objets Future dans votre application. Cette rubrique montre comment combiner des fonctionnalités existantes du Concurrency Runtime pour créer quelque chose de plus puissant.

Une tâche est un calcul qui peut être décomposé en calculs supplémentaires, avec une plus grande granularité. Un objet Future est une tâche asynchrone qui calcule une valeur à utiliser ultérieurement.

Pour implémenter des objets Future, cette rubrique définit la classe async_future. La classe async_future utilise les composants suivants du Concurrency Runtime : la classe concurrency::task\_group et la classe concurrency::single\_assignment. La classe async_future utilise la classe task_group pour calculer une valeur de manière asynchrone et la classe single_assignment pour stocker le résultat du calcul. Le constructeur de la classe async_future prend une fonction de travail qui calcule le résultat, et la méthode get récupère le résultat.

Pour implémenter la classe async_future

1. Déclarez une classe de modèle nommée async_future qui est paramétrée par le type du calcul résultant. Ajoutez les sections public et private à cette classe.

template <typename T>
class async_future
{
public:
private:
};

1. Dans la section private de la classe async_future, déclarez un task_group et un membre de données single_assignment.

// Executes the asynchronous work function.
task_group _tasks;

// Stores the result of the asynchronous work function.
single_assignment<T> _value;

1. Dans la section public de la classe async_future, implémentez le constructeur. Le constructeur est un modèle qui est paramétré par la fonction de travail qui calcule le résultat. Le constructeur exécute de manière asynchrone la fonction de travail dans le membre de données task_group et utilise la fonction concurrency::send pour écrire le résultat dans le membre de données single_assignment.

template <class Functor>
explicit async_future(Functor&& fn)
{
   // Execute the work function in a task group and send the result
   // to the single_assignment object.
   _tasks.run([fn, this]() {
      send(_value, fn());
    });
}

1. Dans la section public de la classe async_future, implémentez le destructeur. Le destructeur attend la fin de la tâche.

~async_future()
{
   // Wait for the task to finish.
   _tasks.wait();
}

1. Dans la section public de la classe async_future, implémentez la méthode get. Cette méthode utilise la fonction concurrency::receive pour récupérer le résultat de la fonction de travail.

// Retrieves the result of the work function.
// This method blocks if the async_future object is still 
// computing the value.
T get()
{ 
   return receive(_value); 
}

Exemple

Descriptif

L’exemple suivant montre la classe async_future complète et un exemple de son utilisation. La wmain fonction crée un objet std ::vector qui contient 10 000 valeurs entières aléatoires. Il utilise ensuite des objets async_future pour trouver les plus petites et les plus grandes valeurs contenues dans l’objet vector.

Code

// futures.cpp
// compile with: /EHsc
#include <ppl.h>
#include <agents.h>
#include <vector>
#include <algorithm>
#include <iostream>
#include <numeric>
#include <random>

using namespace concurrency;
using namespace std;

template <typename T>
class async_future
{
public:
   template <class Functor>
   explicit async_future(Functor&& fn)
   {
      // Execute the work function in a task group and send the result
      // to the single_assignment object.
      _tasks.run([fn, this]() {
         send(_value, fn());
       });
   }

   ~async_future()
   {
      // Wait for the task to finish.
      _tasks.wait();
   }

   // Retrieves the result of the work function.
   // This method blocks if the async_future object is still 
   // computing the value.
   T get()
   { 
      return receive(_value); 
   }

private:
   // Executes the asynchronous work function.
   task_group _tasks;

   // Stores the result of the asynchronous work function.
   single_assignment<T> _value;
};

int wmain()
{
   // Create a vector of 10000 integers, where each element 
   // is between 0 and 9999.
   mt19937 gen(2);
   vector<int> values(10000);   
   generate(begin(values), end(values), [&gen]{ return gen()%10000; });

   // Create a async_future object that finds the smallest value in the
   // vector.
   async_future<int> min_value([&]() -> int { 
      int smallest = INT_MAX;
      for_each(begin(values), end(values), [&](int value) {
         if (value < smallest)
         {
            smallest = value;
         }
      });
      return smallest;
   });
   
   // Create a async_future object that finds the largest value in the
   // vector.
   async_future<int> max_value([&]() -> int { 
      int largest = INT_MIN;
      for_each(begin(values), end(values), [&](int value) {
         if (value > largest)
         {
            largest = value;
         } 
      });
      return largest;
   });

   // Calculate the average value of the vector while the async_future objects
   // work in the background.
   int sum = accumulate(begin(values), end(values), 0);
   int average = sum / values.size();

   // Print the smallest, largest, and average values.
   wcout << L"smallest: " << min_value.get() << endl
         << L"largest:  " << max_value.get() << endl
         << L"average:  " << average << endl;
}

Comments

Cet exemple produit la sortie suivante :

smallest: 0
largest:  9999
average:  4981

L’exemple utilise la méthode async_future::get pour récupérer les résultats du calcul. La méthode async_future::get attend la fin du calcul si celui-ci est toujours actif.

Programmation fiable

Pour étendre la classe async_future afin de gérer les exceptions levées par la fonction de travail, modifiez la méthode async_future::get pour appeler la méthode concurrency::task\_group::wait. La méthode task_group::wait lève toutes les exceptions générées par la fonction de travail.

L’exemple suivant montre la version modifiée de la classe async_future. La fonction wmain utilise un bloc try-catch pour afficher le résultat de l’objet async_future ou pour afficher la valeur de l’exception générée par la fonction de travail.

// futures-with-eh.cpp
// compile with: /EHsc
#include <ppl.h>
#include <agents.h>
#include <vector>
#include <algorithm>
#include <iostream>

using namespace concurrency;
using namespace std;

template <typename T>
class async_future
{
public:
   template <class Functor>
   explicit async_future(Functor&& fn)
   {
      // Execute the work function in a task group and send the result
      // to the single_assignment object.
      _tasks.run([fn, this]() {
         send(_value, fn());
       });
   }

   ~async_future()
   {
      // Wait for the task to finish.
      _tasks.wait();
   }

   // Retrieves the result of the work function.
   // This method blocks if the async_future object is still
   // computing the value.
   T get()
   { 
      // Wait for the task to finish.
      // The wait method throws any exceptions that were generated
      // by the work function.
      _tasks.wait();

      // Return the result of the computation.
      return receive(_value);
   }

private:
   // Executes the asynchronous work function.
   task_group _tasks;

   // Stores the result of the asynchronous work function.
   single_assignment<T> _value;
};

int wmain()
{
   // For illustration, create a async_future with a work 
   // function that throws an exception.
   async_future<int> f([]() -> int { 
      throw exception("error");
   });

   // Try to read from the async_future object. 
   try
   {
      int value = f.get();
      wcout << L"f contains value: " << value << endl;
   }
   catch (const exception& e)
   {
      wcout << L"caught exception: " << e.what() << endl;
   }
}

Cet exemple produit la sortie suivante :

caught exception: error

Pour en savoir plus sur le modèle de gestion des exceptions dans le Concurrency Runtime, veuillez consulter la section Gestion des exceptions.

Compilation du code

Copiez le code d’exemple et collez-le dans un projet Visual Studio, ou collez-le dans un fichier nommé futures.cpp, puis exécutez la commande suivante dans une fenêtre d’invite de commandes Visual Studio.

cl.exe /EHsc futures.cpp

Voir aussi

Procédures pas à pas relatives au runtime d’accès concurrentiel
Gestion des exceptions
Classe task_group
Classe single\_assignment