Wskazówki: wdrażanie przyszłych operacji

Artykuł
06/09/2015

W tym temacie opisano sposób implementacji futures w aplikacji.Temat pokazuje, jak połączyć istniejące funkcje w środowisku wykonawczym współbieżności w coś, co więcej.

Ważne
W tym temacie przedstawiono pojęcia prognozy dla celów demonstracyjnych.Firma Microsoft zaleca użycie std::future lub concurrency::task kiedy wymagają asynchroniczne zadanie, który oblicza wartość do późniejszego użycia.

A zadanie jest obliczeń, która może być rozłożony na dodatkowych i bardziej szczegółowych obliczeń.A przyszłych jest asynchroniczne zadanie, który oblicza wartość do późniejszego użycia.

Aby zaimplementować typu futures, w tym temacie opisano async_future klasy.async_future Klasy używa tych składników w czasie wykonywania współbieżność: concurrency::task_group klasy i concurrency::single_assignment klasy.async_future Klasy zastosowań task_group klasy do obliczenia wartości asynchronicznie i single_assignment klasy do przechowywania wyników obliczeń.Konstruktor async_future klasa wykorzystuje funkcję pracy, która oblicza wynik, i get metoda pobiera wynik.

Aby implementować klasę async_future

Zadeklarować klasę szablonu o nazwie async_future jest sparametryzowana typ wyniku obliczeń.Dodaj public i private sekcje do tej klasy.
```
template <typename T>
class async_future
{
public:
private:
};
```

W private części async_future klasy, oświadczyć, task_group i single_assignment element członkowski danych.

// Executes the asynchronous work function.
task_group _tasks;

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

W public części async_future klasy, implementować konstruktora.Konstruktor jest szablonem, która jest parametryzowana oblicza wynik funkcji pracy.Konstruktor asynchronicznie wykonuje funkcja pracy w task_group element członkowski danych i zastosowań concurrency::send funkcja zapisać wynik do single_assignment element członkowski danych.
```
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());
    });
}
```
W public części async_future klasy, implementować destruktor.Zostanie on czeka na zakończenie zadania.
```
~async_future()
{
   // Wait for the task to finish.
   _tasks.wait();
}
```

W public części async_future klasy, implementować get metody.Ta metoda korzysta z concurrency::receive funkcji do pobierania wynik funkcji pracy.

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

Przykład

Opis

Poniższy przykład przedstawia pełne async_future klasy wraz z przykładem jego użycia.wmain Funkcja tworzy std::vector obiekt, który zawiera wartości 10 000 losową liczbę całkowitą.Następnie używa async_future obiektów do znalezienia najmniejsze i największe wartości, które są zawarte w vector obiektu.

Kod

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

Komentarze

Ten przykład generuje następujące wyniki:

W przykładzie użyto async_future::get metoda pobierania wyniki obliczeń.async_future::get Metoda czeka na obliczeń do końca, jeśli obliczenie jest nadal aktywny.

Niezawodne programowanie

Aby rozszerzyć async_future klasy do obsługi wyjątków, które są generowane przez funkcję pracy, zmień async_future::get metodę do wywołania concurrency::task_group::wait metody.task_group::wait Metoda generuje wyjątki, które zostały wygenerowane przez funkcję pracy.

W poniższym przykładzie pokazano zmodyfikowanej wersji async_future klasy.wmain Funkcja używa try-catch bloku do drukowania wynik async_future obiektu lub umożliwia drukowanie wartości wyjątek, który jest generowany przez funkcję pracy.

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

Ten przykład generuje następujące wyniki:

Aby uzyskać więcej informacji dotyczących modelu obsługi wyjątków w czasie wykonywania współbieżności, zobacz Obsługa wyjątków we współbieżności środowiska wykonawczego.

Kompilowanie kodu

Skopiuj przykładowy kod i wklej go w projekcie programu Visual Studio lub wkleić go w pliku o nazwie futures.cpp , a następnie uruchomić następujące polecenie w oknie wiersza polecenia programu Visual Studio.

cl.exe /EHsc futures.cpp

Zobacz też

Udostępnij za pośrednictwem

Wskazówki: wdrażanie przyszłych operacji

Aby implementować klasę async_future

Przykład

Opis

Kod

Komentarze

Niezawodne programowanie

Kompilowanie kodu

Zobacz też

Informacje

Koncepcje

Inne zasoby

Dodatkowe zasoby