Passo a passo: implementando futuros

Artigo
02/25/2013

Este tópico mostra como implementar futuros em seu aplicativo.O tópico demonstra como combinar a funcionalidade existente em tempo de execução de simultaneidade em algo que faz mais.

Importante
Este tópico ilustra o conceito de futuros para fins de demonstração.Recomendamos que você usa std::future ou concurrency::task quando você precisar de uma tarefa assíncrona que compute um valor para uso posterior.

Uma tarefa é uma computação que pode ser decompor em adicional, mais mais aguçado, os cálculos.Um futuro é uma tarefa assíncrona que compute um valor para uso posterior.

Para implementar futuros, este tópico define a classe de async_future .A classe de async_future usa esses componentes de tempo de execução de concorrência: a classe de concurrency::task_group e a classe de concurrency::single_assignment .A classe de async_future usa a classe para calcular de task_group de forma assíncrona um valor e a classe de single_assignment para armazenar o resultado de computação.O construtor da classe de async_future usa uma função de trabalho que compute o resultado, e o método de get retorna o resultado.

Para implementar a classe de async_future

Declare uma classe de modelo chamada async_future que é parametrizada no tipo de computação resultante.Adicione public e seções de private a essa classe.
```
template <typename T>
class async_future
{
public:
private:
};
```

Na seção de private da classe de async_future , declare task_group e um membro de dados de single_assignment .

// Executes the asynchronous work function.
task_group _tasks;

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

Na seção de public da classe de async_future , implemente o construtor.O construtor é um modelo que é parametrizada na função de trabalho que calcula o resultado.O construtor de forma assíncrona executa a função de trabalho no membro de dados de task_group e usa a função de concurrency::send para escrever o resultado para o membro de dados de 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());
    });
}
```
Na seção de public da classe de async_future , implemente o destrutor.O destrutor espera a tarefa termina.
```
~async_future()
{
   // Wait for the task to finish.
   _tasks.wait();
}
```
Na seção de public da classe de async_future , implemente o método de get .Este método usa a função de concurrency::receive para recuperar o resultado da função de trabalho.
```
// 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); 
}
```

Exemplo

Descrição

O exemplo a seguir mostra a classe completa de async_future e um exemplo de uso.A função de wmain cria um objeto de std::vector que contém 10.000 valores inteiros aleatórios.Usar objetos de async_future para localizar os menores e os maiores que estão contidos no objeto de vector .

Código

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

Comentários

Esse exemplo produz a seguinte saída.

O exemplo usa o método de async_future::get para recuperar os resultados de computação.O método de async_future::get espera a computação para concluir se a computação ainda está ativa.

Programação robusta

Para estender async_future classe para manipular exceções que são geradas pela função de trabalho, alteram o método de async_future::get para chamar o método de concurrency::task_group::wait .O método de task_group::wait joga todas as exceções que são geradas pela função de trabalho.

O exemplo a seguir mostra a versão modificada da classe de async_future .A função de wmain usa um bloco de try- decatch para imprimir o resultado do objeto de async_future ou para imprimir o valor de exceção que é gerada pela função de trabalho.

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

Esse exemplo produz a seguinte saída.

Para obter mais informações sobre o modelo de manipulação de exceção em tempo de execução de concorrência, consulte Manipulação de exceção em tempo de execução de concorrência.

Compilando o código

Copie o código de exemplo e cole-o em um projeto do Visual Studio, ou cole em um arquivo denominado futures.cpp e execute o seguinte comando em uma janela de prompt de comando do Visual Studio.

cl.exe /EHsc futures.cpp

Consulte também

Partilhar via

Passo a passo: implementando futuros

Para implementar a classe de async_future

Exemplo

Descrição

Código

Comentários

Programação robusta

Compilando o código

Consulte também

Referência

Conceitos

Outros recursos

Recursos adicionais