Question

在这个小例子中，我试图将std::thread与std::async进行比较，以进行有趣的练习。我生成了8个向量，其中有10个随机数（从0到1000）。然后将这些向量推入队列，以便稍后继续进行多线程排序。这是我用来生成随机数的函数：

std::vector<int> generate(int count)
{
  std::vector<int> newVec(count);
  std::random_device rd;
  std::mt19937 mt(rd());
  std::uniform_int_distribution<> dis(0,1000);

  std::generate(begin(newVec),end(newVec),std::bind(dis,std::ref(mt)));

  return newVec;
}

在我的线程示例中，我只是锁定队列，从中获取一个向量，在其上调用std::sort，然后将其推回到向量列表中，这样我就可以将其合并为一个最终向量。结束。实施起来很容易，但是我正在尝试找出如何使用std::async来实现同样的事情。这是我到目前为止已经尝试过的事情：

void work(std::deque<std::vector<int>>& queue, std::list<std::vector<int>> toMerge)
{
  std::vector<int> temp;
  temp = queue.front();
  auto handle = std::async(std::launch::async,sortIt,temp);
  queue.pop_front();
  toMerge.push_back(temp);

}

然后我意识到，这不会达到我的预期。我不相信这会一遍又一遍。所以我尝试了这个：

void work(std::deque<std::vector<int>>& queue, std::list<std::vector<int>> toMerge)
{
  if(queue.empty()
  {
    return;
  }
  else
  {
    auto handle = std::async(std::launch::async[&]{return std::sort(queue.front.begin(),queue.front.end());},work,queue,toMerge);
  }
}

但这给了我各种各样我不知道如何解决的编译器错误。

我该如何完成这项任务？

完整代码：

void sortIt(std::vector<int>& v)
{
  std::sort(begin(v),end(v));
}

void print(std::vector<int> &v)
{
  for(auto &&e : v)
  {
    std::cout << e << " ";
  }
  std::cout << std::endl;
}

std::vector<int> generate(int count)
{
  std::vector<int> newVec(count);
  std::random_device rd;
  std::mt19937 mt(rd());
  std::uniform_int_distribution<> dis(0,1000);

  std::generate(begin(newVec),end(newVec),std::bind(dis,std::ref(mt)));

  return newVec;
}

void work(std::deque<std::vector<int>>& queue, std::list<std::vector<int>> toMerge)
{
  //TODO: Make asnyc work
}

int main()
{
  std::deque<std::vector<int>> queue; 
  std::vector<int> tempA;
  std::vector<int> tempB;
  std::vector<int> finalVec;
  std::list<std::vector<int>> toMerge;

  for(int i = 0; i < 8; ++i)
  {
    queue.push_back(generate(10));
  }

  work(queue,toMerge);

}

Answer 1

您需要做的就是创建用于保存未来对象的向量，遍历queue并在每次迭代器调用async函数开始异步操作-在您的情况下，它是对向量进行排序。对于每个将来的对象，您必须调用get方法以检索排序的向量。由get获得的排序向量将添加到toMerge列表中。

void work(
  const std::deque<std::vector<int>>& queue, // const added - don't modify queue
  std::list<std::vector<int>>& toMerge) // pass toMerge by reference to store results
{
  std::vector<std::future< std::vector<int> >> tasks;
  for (const std::vector<int>& v : queue)
    tasks.push_back (std::async(
                                [vecCopy = v]() mutable { // copy v into vecCopy 
                                   std::sort(vecCopy.begin(), vecCopy.end()); 
                                   return vecCopy; 
                                }));

  // wait until all tasks are complete
  for (std::future< std::vector<int> >& f : tasks)
    toMerge.push_back(f.get()); // move vector into list
}

Lambda排序如下：

[vecCopy = v]() mutable { // copy v into vecCopy  
      std::sort(vecCopy.begin(), vecCopy.end()); 
      return vecCopy; 
}

您不想从v修改queue，因此复制了v， v的内容被复制到vecCopy中。因为关闭保留vecCopy的值，您需要将 mutable 关键字放入lambda以允许 vecCopy进行修改。

如何在向量队列或向量向量上使用std :: async进行排序？

1 个答案: