您如何将 AsParallel 与 async 和 await 关键字一起使用？

Question

我正在查看某人的异步示例代码，并注意到它的实现方式存在一些问题。在查看代码时，我想知道使用 as 并行循环遍历列表是否比正常循环遍历列表更有效。

据我所知，性能差异很小，两者都用尽了每个处理器，并且都在相同的时间内完成。

这是第一种方法

var tasks= Client.GetClients().Select(async p => await p.Initialize());

这是第二个

var tasks = Client.GetClients().AsParallel().Select(async p => await p.Initialize());

我是否正确假设两者之间没有区别？

完整的程序可以在下面找到

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            RunCode1();
            Console.WriteLine("Here");
            Console.ReadLine();

            RunCode2();
            Console.WriteLine("Here");

            Console.ReadLine();

        }

        private async static void RunCode1()
        {
            Stopwatch myStopWatch = new Stopwatch();
            myStopWatch.Start();

            var tasks= Client.GetClients().Select(async p => await p.Initialize());

            Task.WaitAll(tasks.ToArray());
            Console.WriteLine("Time ellapsed(ms): " + myStopWatch.ElapsedMilliseconds);
            myStopWatch.Stop();
        }
        private async static void RunCode2()
        {
            Stopwatch myStopWatch = new Stopwatch();
            myStopWatch.Start();
            var tasks = Client.GetClients().AsParallel().Select(async p => await p.Initialize());
            Task.WaitAll(tasks.ToArray());
            Console.WriteLine("Time ellapsed(ms): " + myStopWatch.ElapsedMilliseconds);
            myStopWatch.Stop();
        }
    }
    class Client
    {
        public static IEnumerable<Client> GetClients()
        {
            for (int i = 0; i < 100; i++)
            {
                yield return new Client() { Id = Guid.NewGuid() };
            }
        }

        public Guid Id { get; set; }

        //This method has to be called before you use a client
        //For the sample, I don't put it on the constructor
        public async Task Initialize()
        {
            await Task.Factory.StartNew(() =>
                                      {
                                          Stopwatch timer = new Stopwatch();
                                          timer.Start();
                                          while(timer.ElapsedMilliseconds<1000)
                                          {}
                                          timer.Stop();

                                      });
            Console.WriteLine("Completed: " + Id);
        }
    }
}

Answer 1

应该几乎没有可辨别的差异。

在您的第一种情况下：

var tasks = Client.GetClients().Select(async p => await p.Initialize());

执行线程将（一次一个）开始为客户端列表中的每个元素执行Initialize。 Initialize 立即将一个方法排入线程池并返回一个未完成的Task。

在你的第二种情况下：

var tasks = Client.GetClients().AsParallel().Select(async p => await p.Initialize());

执行线程将分叉到线程池并（并行）开始为客户端列表中的每个元素执行Initialize。 Initialize 具有相同的行为：它立即将一个方法排队到线程池并返回。

这两个时间几乎相同，因为您只是并行化少量代码：将方法排队到线程池和返回未完成的Task。

如果Initialize 在其第一个await 之前做了一些更长的（同步）工作，那么使用AsParallel 可能是有意义的。

请记住，所有 async 方法（和 lambda）一开始都是同步执行的（请参阅 official FAQ 或 my own intro post）。

Answer 2

有一个独特的主要区别。

在以下代码中，您将自行执行分区。换句话说，您正在从调用GetClients() 返回的IEnumerable<T> 中为每个项目创建一个Task 对象：

var tasks= Client.GetClients().Select(async p => await p.Initialize());

在第二个中，对AsParallel 的调用将在内部使用Task 实例来执行IEnumerable<T> 的分区并且您将拥有初始的Task从 lambda async p => await p.Initialize() 返回：

var tasks = Client.GetClients().AsParallel().
    Select(async p => await p.Initialize());

最后，在这里使用async/await 并没有真正做任何事情。当然，编译器可能会对此进行优化，但您只是在等待一个返回 Task 的方法，然后返回一个通过 lambda 什么都不做的延续。也就是说，由于对Initialize 的调用已经返回Task，因此最好保持简单，然后执行以下操作：

var tasks = Client.GetClients().Select(p => p.Initialize());

这将为您返回Task 实例的序列。

Answer 3

要改进上述 2 个答案，这是获得可等待的异步/线程执行的最简单方法：

var results = await Task.WhenAll(Client.GetClients().Select(async p => p.Initialize()));

这将确保它旋转单独的线程并最终获得结果。希望对某人有所帮助。我花了很长时间才弄清楚这一点，因为这不是很明显，而且 AsParallel() 函数似乎是你想要的，但不使用 async/await。