VS2010点滴——Concurrency Runtime namespace（异步编程三）

任务组：

在之前我们介绍的异步操作都是基于Task<>的，这个是被封装好的类，可以作为传入，或者传出参数。下面我们要介绍的任务组的概念，他是比Task<>更轻量级的异步调用方式。

在PPL中Concurrency::task_group和Concurrency::structured_task_group，这两个类都是异步操作的任务组，Concurrency::task_handle类是任务组的基本单位。

 

我们先用 Concurrency::structured_task_group举例，我们通过structured_task_group::run 去添加任务，这个任务就是 Concurrency::task_handle，他的构造函数参数可以是函数指针，结构体重载（）操作符，或者是lambda表达式。我们通过structured_task_group::wait去执行已经添加的任务，或者通过structured_task_group::run_and_wait去添加并执行所有的任务

#include "stdafx.h"
#include 
#include 
#include 
using namespace Concurrency;
using namespace std;

const struct functionstruct{
    void operator ()() const
    {
        cout<<"This is override struct operator "<     }
}myfunction;

void taskfuncton ()
{
    cout<<"This is function point"< }
int _tmain(int argc, _TCHAR* argv[])
{
    // Function point
    auto task1=make_task(&taskfuncton);
    // Struct with () operator
    auto task2 = make_task(myfunction);
    // Lambda express
    auto task3 = make_task([] { cout<<"This is lambed express"<
    // Create a structured task group and run the tasks concurrently.

    structured_task_group tasks;

    tasks.run(task1);
    tasks.run(task2);
    tasks.run_and_wait(task3);
    return 0;

} 

 

这里要注意一点的就是，这里的task都必须是没有返回值和传入参数的函数，或者lambda表达式。这就是和基于task<>最大的不同，基于task<>的任务组需要用when_all或者when_any来调度，我们可以获得到task<>的返回值，而structured_task_group不允许函数有传入和传出参数。

 

我们也可以创建一个数状的任务组，如下图 

 

 

对应的代码是

// task-tree.cpp
// compile with: /c /EHsc
#include 
#include 
#include 
#include 

using namespace Concurrency;
using namespace std;

void create_task_tree()
{   
   // Create a task group that serves as the root of the tree.
   structured_task_group tg1;

   // Create a task that contains a nested task group.
   auto t1 = make_task([&] {
      structured_task_group tg2;

      // Create a child task.
      auto t4 = make_task([&] {
         // TODO: Perform work here.
      });

      // Create a child task.
      auto t5 = make_task([&] {
         // TODO: Perform work here.
      });

      // Run the child tasks and wait for them to finish.
      tg2.run(t4);
      tg2.run(t5);
      tg2.wait();
   });

   // Create a child task.
   auto t2 = make_task([&] {
      // TODO: Perform work here.
   });

   // Create a child task.
   auto t3 = make_task([&] {
      // TODO: Perform work here.
   });

   // Run the child tasks and wait for them to finish.
   tg1.run(t1);
   tg1.run(t2);
   tg1.run(t3);
   tg1.wait();   

} 

 

 我们可以通过structured_task_group::cancel 在内部或者外部来取消整个任务组，通过structured_task_group::is_canceling 来得到取消状态。

对于异常我们要在.wait()方法外面加try_catch

structured_task_group tg2;

// Create a child task.      
auto t4 = make_task([&] {
   // Perform work in a loop.
   for (int i = 0; i < 1000; ++i)
   {
      // Call a function to perform work.
      // If the work function fails, throw an exception to 
      // cancel the parent task.
      bool succeeded = work(i);
      if (!succeeded)
      {
         throw exception("The task failed");
      }
   }         
});

// Create a child task.
auto t5 = make_task([&] {
   // TODO: Perform work here.
});

// Run the child tasks.
tg2.run(t4);
tg2.run(t5);

// Wait for the tasks to finish. The runtime marshals any exception
// that occurs to the call to wait.
try
{
   tg2.wait();
}
catch (const exception& e)
{
   wcout << e.what() << endl;

}

 

上面说完了  Concurrency::structured_task_group，Concurrency::task_group 的使用方法基本上和前者类似。但是后者比前者更灵活，同样消耗的资源也更多。

下面是他们两个之间不同的地方。 

1. task_group是线程安全的，可以在别的线程里面通过run添加task, structured_task_group不允许多线程操作，而且所有的操作必须写在一个线程代码块里。

2.  task_group可以再wait()方法执行之后，再通过run 方法添加task，而structured_task_group是固定的，.wait()后不能再添加。

3. structured_task_group 建立的任务组树，子节点必须在父节点里面调用wait()的方法，因为structured_task_group只能在一个线程代码块里面执行，所以子节点必须要调用wait()，而task_group不需要。

4.task_group 添加任务不需要调用make_task()方法， structured_task_group 必须调用。

    task_group tasks;

    tasks.run(&taskfuncton);
    tasks.run(myfunction);

    tasks.run_and_wait([] { cout<<"This is lambed express"<

 

总之， task_group较之structured_task_group又多封装了很多东西，如果没有特殊需要structured_task_group可以写出更高效的代码。