演练：实现 Future

项目
08/12/2011

本主题将说明如何在应用程序中实现 Future。本主题演示如何将并发运行时中的现有功能合并为可以完成更多任务的功能。

任务是一个可以分解为更多且更细化计算的计算。将来是计算值以供将来使用的异步任务。

为了实现 Future，本主题定义了 async_future 类。 async_future 类使用并发运行时的以下组件：Concurrency::task_group 类和 Concurrency::single_assignment 类。 async_future 类使用 task_group 类异步计算值，并使用 single_assignment 类存储计算结果。 async_future 类的构造函数采用一个用于计算结果的工作函数，而 get 方法将检索结果。

实现 future 类

声明一个名为 async_future 的模板类，并且其参数化由结果计算的类型确定。向此类添加 public 和 private 部分。
```
template <typename T>
class async_future
{
public:
private:
};
```

在 async_future 类的 private 部分中，声明 task_group 和 single_assignment 数据成员。

// Executes the asynchronous work function.
task_group _tasks;

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

在 async_future 类的 public 部分中，实现构造函数。构造函数是一个模板，其参数化由计算结果的工作函数确定。构造函数异步执行 task_group 数据成员中的工作函数，并使用 Concurrency::send 函数将结果写入 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());
    });
}
```
在 async_future 类的 public 部分中，实现析构函数。析构函数将会等待任务完成。
```
~async_future()
{
   // Wait for the task to finish.
   _tasks.wait();
}
```

在 async_future 类的 public 部分，实现 get 方法。该方法使用 Concurrency::receive 函数检索工作函数的结果。

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

示例

说明

下面的示例演示完整的 async_future 类以及该类的用法示例。 wmain 函数会创建一个 std::vector 对象，此对象包含 10,000 个随机的整数值。然后该函数使用 async_future 对象查找此 vector 对象中包含的最小值和最大值。

代码

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

注释

该示例产生下面的输出：

smallest: 0
largest:  9999
average:  4981

该示例使用 async_future::get 方法来检索计算的结果。如果计算仍处于活动状态，则 async_future::get 方法会等待计算完成。

可靠编程

若要扩展 async_future 类以处理工作函数引发的异常，请修改 async_future::get 方法以调用 Concurrency::task_group::wait 方法。 task_group::wait 方法将引发由工作函数生成的任何异常。

下面的示例显示的是 async_future 类的修改后的版本。 wmain 函数使用 try-catch 块来输出 async_future 对象的结果，或者输出由工作函数生成的异常的值。

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

该示例产生下面的输出：

caught exception: error

有关并发运行时中的异常处理模型的更多信息，请参见并发运行时中的异常处理。

编译代码

复制代码示例，再将此代码粘贴到 Visual Studio 项目中或一个名为 futures.cpp 的文件中，然后在 Visual Studio 2010 命令提示符窗口中运行以下命令。

cl.exe /EHsc futures.cpp

请参见

通过

演练：实现 Future

实现 future 类

示例

说明

代码

注释

可靠编程

编译代码

请参见

参考

概念

其他资源

其他资源