Procedura dettagliata: implementazione di future

Articolo
08/11/2011

In questo argomento viene illustrato come implementare future nell'applicazione. Viene inoltre illustrato come combinare le funzionalità esistenti del runtime di concorrenza con funzionalità ancora più avanzate.

Un'attività è un calcolo che può essere scomposto in calcoli aggiuntivi più accurati. Una future è un'attività asincrona che calcola un valore per un utilizzo successivo.

Per implementare le future, in questo argomento viene definita la classe async_future. La classe async_future utilizza i seguenti componenti del runtime di concorrenza: la classe Concurrency::task_group e la classe Concurrency::single_assignment. La classe async_future utilizza la classe task_group per calcolare un valore in modo asincrono e la classe single_assignment per archiviare il risultato del calcolo. Il costruttore della classe async_future accetta una funzione lavoro che calcola il risultato e il metodo get recupera il risultato.

Per implementare la classe future

Dichiarare una classe modello denominata async_future contenente i parametri per il tipo del calcolo risultante. Aggiungere a questa classe le sezioni public e private.
```
template <typename T>
class async_future
{
public:
private:
};
```

Nella sezione private della classe async_future dichiarare un membro dati task_group e single_assignment.

// Executes the asynchronous work function.
task_group _tasks;

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

Nella sezione public della classe async_future implementare il costruttore. Il costruttore è un modello contenente i parametri per la funzione lavoro che calcola il risultato. Il costruttore esegue in modo asincrono la funzione lavoro nel membro dati task_group e utilizza la funzione Concurrency::send per scrivere il risultato nel membro dati 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());
    });
}
```
Nella sezione public della classe async_future implementare il distruttore. Il distruttore attende il completamento dell'attività.
```
~async_future()
{
   // Wait for the task to finish.
   _tasks.wait();
}
```
Nella sezione public della classe async_future implementare il metodo get. Questo metodo utilizza la funzione Concurrency::receive per recuperare il risultato della funzione lavoro.
```
// 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); 
}
```

Esempio

Descrizione

Nell'esempio seguente viene illustrata la classe async_future completa e un esempio del relativo utilizzo. La funzione wmain crea un oggetto std::vector che contiene 10.000 valori interi casuali. Utilizza quindi gli oggetti async_future per trovare i valori minimo e massimo contenuti nell'oggetto vector.

Codice

// 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(values.begin(), values.end(), [&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(values.begin(), values.end(), [&](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(values.begin(), values.end(), [&](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(values.begin(), values.end(), 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;
}

Commenti

Questo esempio produce il seguente output:

smallest: 0
largest:  9999
average:  4981

Nell'esempio viene utilizzato il metodo async_future::get per recuperare i risultati del calcolo. Se il calcolo è ancora attivo, il metodo async_future::get ne attende il completamento.

Programmazione robusta

Per estendere la classe async_future per gestire le eccezioni generate dalla funzione lavoro, modificare il metodo async_future::get in modo da chiamare il metodo Concurrency::task_group::wait. Il metodo task_group::wait genera tutte le eccezioni generate dalla funzione lavoro.

Nell'esempio seguente viene illustrata la versione modificata della classe async_future. La funzione wmain utilizza un blocco try-catch per visualizzare il risultato dell'oggetto async_future o per visualizzare il valore dell'eccezione generata dalla funzione lavoro.

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

Questo esempio produce il seguente output:

caught exception: error

Per ulteriori informazioni sul modello di gestione delle eccezioni nel runtime di concorrenza, vedere Gestione delle eccezioni nel runtime di concorrenza.

Compilazione del codice

Copiare il codice di esempio e incollarlo in un progetto di Visual Studio o incollarlo in un file denominato future.cpp, quindi eseguire il comando seguente in una finestra del prompt dei comandi di Visual Studio 2010.

cl.exe /EHsc futures.cpp

Vedere anche

Condividi tramite

Procedura dettagliata: implementazione di future

Per implementare la classe future

Esempio

Descrizione

Codice

Commenti

Programmazione robusta

Compilazione del codice

Vedere anche

Riferimenti

Concetti

Altre risorse

Risorse aggiuntive