异步运行同一方法的多个实例？

Question

我的要求很奇怪。

我有SomeMethod()，它调用GetDataFor()。

public void SomeMethod()
{
    for(int i = 0; i<100; i++) {
        var data = GetDataFor(i);
    }
}

public data GetDataFor(int i) {
    //call a remote API
    //to generate data for i
    //store to database
    return data;
}

对于每个i，最终结果将总是不同。在调用GetDataFor(i+1) 之前，无需等待GetDataFor(i) 完成。

换句话说，我需要：

• 在成功调用i后立即为每个i+1调用GetDataFor()（并行调用它们看起来不可能）
• 等到所有 GetDataFor() 的 100 个实例完成运行
• 离开SomeMethod()的范围

按照YK1's answer，我尝试过这样修改：

public async Task<void> SomeMethod()
{
    for(int i = 0; i < 100; i++) {
        var task = Task.Run(() => GetDataFor(i));
        var data = await task;
    }
}

它没有抛出任何错误，但我需要了解这背后的概念：

• task 将如何区分对awaiting 的不同调用？它正在被覆盖。
• 这样做是不是公然错误的方法？那么，如何做到正确呢？

Answer 1

你可以使用Parallel.For:

public void SomeMethod()
{
    Parallel.For(0, 100, i =>
    {
        var data = GetDataFor(i);
        //Do something
    });
}

public data GetDataFor(int i)
{
    //generate data for i
    return data;
}

编辑：

并行循环的语法与您已经知道的for 和foreach 循环非常相似，但并行循环在具有可用内核的计算机上运行得更快。另一个区别是，与顺序循环不同，并行循环没有定义执行顺序。步骤通常同时并行进行。有时，两个步骤的执行顺序与循环顺序相反。唯一的保证是所有循环的迭代都将在循环结束时运行。

对于并行循环，您的代码不需要指定并行度。相反，运行时环境在尽可能多的内核上同时执行循环的步骤。无论有多少内核可用，循环都能正常工作。如果只有一个核心，则性能接近（可能在几个百分点之内）顺序等效。如果有多个核心，性能会提高；在许多情况下，性能会随着内核数量的增加而提高。

你可以看到更详细的解释here。

Answer 2

有几种不同的方法。

首先，您可以让它保持同步，然后并行执行它们（在不同的线程上）。 Parallel LINQ 优于Parallel如果你想在调用方法中收集所有结果继续：

public data[] SomeMethod()
{
  return Enumerable.Range(0, 100)
      .AsParallel().AsOrdered()
      .Select(GetDataFor).ToArray();
}

其次，你可以让它异步。要使某些东西真正异步，您需要从最低级别开始（在这种情况下，“调用远程 API”和“存储到数据库”）并使其异步首先。然后你可以让GetDataFor异步：

public async Task<data> GetDataForAsync(int i)
{
  await .. //call a remote API asynchronously
  await .. //store to database asynchronously
  return data;
}

那么你也可以使SomeMethod异步：

public Task<data[]> SomeMethodAsync()
{
  return Task.WhenAll(
      Enumerable.Range(0, 100).Select(GetDataForAsync)
  );
}

使代码异步需要更多工作 - 更多代码必须更改 - 但在可扩展性和资源使用方面更好。

Answer 3

当使用asyncawait时，你实际上是在说“在等待这个任务完成的同时，请去做一些不依赖这个任务的独立工作”。由于您不关心等待 GetDataFor 完成，因此您并不想使用 async await。

This previous question 的请求似乎与您的请求非常相似。考虑到这一点，我认为您应该能够执行以下操作：

public void SomeMethod()
{
    Task.Run(() => GetDataFor(i));
}

基本上，这假设您无需等待 GetDataFor 完成即可执行任何其他操作，这实际上是“一劳永逸”。

对于 Parallel.For，只要您拥有 1 个以上的内核，您就可能会看到性能有所提升。如果没有，您可能会看到性能略有下降（更多开销）。 Here's an article 这有助于解释它是如何工作的。

更新

根据您的评论，我会建议如下：

var TList = new List<Task>();

for (var i = 0; i < 100; i++)
{
    TList.Add(Task.Run(() => GetDataFor(i)));
}

await Task.WhenAll(TList);     

Here's a useful question 强调了为什么您可能希望使用 WhenAll 而不是 WaitAll。

您可能希望对任务的完成状态进行一些检查，以查看哪些失败（如果有）。示例见here。

Answer 4

我会改为将每个任务添加到一个集合中，然后在循环之后等待整个集合。

在这样的循环内部等待会产生大量的延续和超出预期的开销，包括等待每个调用完成，然后再继续我相信的循环。

改为查看 awaiting Task.WaitAll。

如果每个任务的值对处理很重要，则查看等待Task.WhenAll，然后将每个任务的结果读入您的返回集合。

Answer 5

代码实际上没有意义。

任务如何区分不同的等待调用？它越来越 重写。

它不会被覆盖。因为……

for(int i = 0; i < 100; i++) {
    var task = Task.Run(() => GetDataFor(i));
    var data = await task;
}

这是在继续循环之前等待每个请求完成。 await 等待结束。

这意味着整个任务是无关紧要的——这里没有并行发生。您可以通过在没有任务的情况下执行此操作来减少一些小开销。

我怀疑 OP 想要实现一些他根本没有做到的事情，并且他没有花费足够的时间进行调试以意识到他再次单线程了整个循环。

Answer 6

虽然您的原始代码会覆盖这些值，但您似乎正在尝试合并并行操作的结果。如果是这样，请考虑使用Task.ContinueWith 来处理返回值。您的代码将如下所示：

public void SomeMethod()
    List<Task> tasks = new List<Task>();
    for (var i = 0; i < 100; i++)
    {
        tasks.Add(Task.Run(() => GetDataFor(i)).ContinueWith((antecedent) => {
            // Process the results here.
        }));
    }
    Task.WaitAll(tasks.ToArray());
}