尝试与 .WhenAll 并行运行多个任务，但任务没有并行运行

Question

我有一种将 csv 文件转换为特定模型的方法，我想将其拆分为多个任务，因为有 700k+ 条记录。我在方法中使用了.Skip 和.Take，所以每次运行该方法都知道从哪里开始以及需要多少。我有一个数字 1-10 的列表，我想对其进行迭代并创建任务来运行此方法，使用该迭代器创建任务并进行一些数学运算以确定要跳过多少条记录。

这是我创建任务的方式：

var numberOfTasksList = Enumerable.Range(1, 10).ToList();
//I left out the math to determine rowsPerTask used as a parameter in the below method for brevity's sake
var tasks = numberOfTasksList.Select(i
                =>  ReadRowsList<T>(props, fields, csv, context, zohoEntities, i, i*rowsPerTask, (i-1)*rowsPerTask));

           await Task.WhenAll(tasks);

使用的ReadRowsList 方法如下所示（不带参数）：

public static async Task<string> ReadRowsList<T>(...parameters) where T : class, new()
   {
     //work to run
     return $"added rows for task {i}";
   }

它返回的那个方法的字符串只是一个简单的行，上面写着 $" added rows for task {i}" 所以它不是一个真正的异步/等待，因为我只是返回一个字符串来说明迭代何时完成.

但是，当我运行程序时，该方法会等待第一次迭代（其中 i=1）完成，然后再开始运行程序的第二次迭代，因此它不是并行运行的。在异步/并行编程方面，我不是最好的，但是有什么明显的事情会导致任务必须等到上一个迭代完成才能开始下一个任务？据我了解，使用上述代码创建任务并使用.WhenAll(tasks) 会为每次迭代创建一个新线程，但我一定会遗漏一些东西。

Answer 1

简而言之：

1. async 不等于多线程；和
2. 创建函数 async Task 不会使其异步

当Task.WhenAll 使用没有awaits 的假装异步代码运行时，当前线程无法“释放”手头的任务，也无法开始处理另一个任务。

正如 cmets 中所指出的，构建链通过以下方式警告您： This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.

简单的例子

让我们考虑两个具有相同签名的函数，一个带有异步代码，一个没有。

static async Task DoWorkPretendAsync(int taskId)
{
    Console.WriteLine($"Thread: {Thread.CurrentThread.ManagedThreadId} -> task:{taskId} > start");
    Thread.Sleep(TimeSpan.FromSeconds(1));
    Console.WriteLine($"Thread: {Thread.CurrentThread.ManagedThreadId} -> task:{taskId} > done");
}

static async Task DoWorkAsync(int taskId)
{
    Console.WriteLine($"Thread: {Thread.CurrentThread.ManagedThreadId} -> task:{taskId} > start");
    await Task.Delay(TimeSpan.FromSeconds(1));
    Console.WriteLine($"Thread: {Thread.CurrentThread.ManagedThreadId} -> task:{taskId} > done");
}

如果我们用下面的 sn-p 测试它们

await DoItAsync(DoWorkPretendAsync);
Console.WriteLine();
await DoItAsync(DoWorkAsync);

async Task DoItAsync(Func<int, Task> f)
{
    var tasks = Enumerable.Range(start: 0, count: 3).Select(i => f(i));
    Console.WriteLine("Before WhenAll");
    await Task.WhenAll(tasks);
    Console.WriteLine("After WhenAll");
}

我们可以看到DoWorkPretendAsync的任务是按顺序执行的。

Before WhenAll
Thread: 1 -> task:0 > start
Thread: 1 -> task:0 > done
Thread: 1 -> task:1 > start
Thread: 1 -> task:1 > done
Thread: 1 -> task:2 > start
Thread: 1 -> task:2 > done
After WhenAll

Before WhenAll
Thread: 1 -> task:0 > start
Thread: 1 -> task:1 > start
Thread: 1 -> task:2 > start
Thread: 5 -> task:0 > done
Thread: 5 -> task:2 > done
Thread: 7 -> task:1 > done
After WhenAll

注意事项：

• 即使是真正的异步，所有任务都是由同一个线程启动的；
• 在这个特定的运行中，两个任务由同一个线程 (id:5) 完成。这根本无法保证 - 一个任务可以在一个线程上启动，然后在池中的另一个线程上继续。