MVC4 异步和并行执行

Question

因此，我正在尝试了解 .net 4.5 中的新“异步”内容。我之前玩过一些异步控制器和任务并行库，最后得到了这段代码：

采用这个模型：

public class TestOutput
{
    public string One { get; set; }
    public string Two { get; set; }
    public string Three { get; set; }

    public static string DoWork(string input)
    {
        Thread.Sleep(2000);
        return input;
    }
}

它在这样的控制器中使用：

public void IndexAsync()
{
    AsyncManager.OutstandingOperations.Increment(3);

    Task.Factory.StartNew(() => 
        { 
            return TestOutput.DoWork("1"); 
        })
        .ContinueWith(t => 
        { 
            AsyncManager.OutstandingOperations.Decrement(); 
            AsyncManager.Parameters["one"] = t.Result; 
        });
    Task.Factory.StartNew(() =>
        {
            return TestOutput.DoWork("2");
        })
        .ContinueWith(t =>
        {
            AsyncManager.OutstandingOperations.Decrement();
            AsyncManager.Parameters["two"] = t.Result;
        });
    Task.Factory.StartNew(() =>
        {
            return TestOutput.DoWork("3");
        })
        .ContinueWith(t =>
        {
            AsyncManager.OutstandingOperations.Decrement();
            AsyncManager.Parameters["three"] = t.Result;
        });
}

public ActionResult IndexCompleted(string one, string two, string three)
{
    return View(new TestOutput { One = one, Two = two, Three = three });
}

这个控制器在2秒内渲染视图，感谢 TPL 的魔力。

现在，我期望（相当天真地）使用 C# 5 的新“异步”和“等待”功能，上面的代码将转换为以下内容：

public async Task<ActionResult> Index()
{
    return View(new TestOutput
    {
        One = await Task.Run(() =>TestOutput.DoWork("one")),
        Two = await Task.Run(() =>TestOutput.DoWork("two")),
        Three = await Task.Run(() =>TestOutput.DoWork("three"))
    });
}

此控制器在 6 秒内呈现视图。在翻译的某个地方，代码变得不再并行。我知道异步和并行是两个不同的概念，但不知何故我认为代码的工作原理是相同的。有人可以指出这里发生了什么以及如何解决它吗？

Answer 1

在翻译的某个地方，代码变得不再并行。

恰恰。 await 将（异步）等待单个操作完成。

并行异步操作可以通过启动实际的Task来完成，但稍后才await它们：

public async Task<ActionResult> Index() 
{
  // Start all three operations.
  var tasks = new[]
  {
    Task.Run(() =>TestOutput.DoWork("one")), 
    Task.Run(() =>TestOutput.DoWork("two")), 
    Task.Run(() =>TestOutput.DoWork("three"))
  };

  // Asynchronously wait for them all to complete.
  var results = await Task.WhenAll(tasks);

  // Retrieve the results.
  return View(new TestOutput
  {
    One = results[0],
    Two = results[1],
    Three = results[2]
  }); 
} 

PS还有一个Task.WhenAny。

Answer 2

不，你已经说明了这是不同的原因。并行和异步是两个不同的东西。

Task 版本的工作时间为 2 秒，因为它同时运行三个操作（只要您有 3 个以上的处理器）。

实际上，await 顾名思义，代码将等待 Task.Run 的执行，然后再继续执行下一行代码。

因此，TPL 版本和异步版本之间的最大区别在于，TPL 版本可以任意顺序运行，因为所有任务都是相互独立的。而异步版本则按照代码编写的顺序运行。因此，如果您想要并行，请使用 TPL，如果您想要异步，请使用异步。

异步的要点是能够编写看起来同步的代码，在发生长时间运行的操作时不会锁定 UI。然而，这通常是处理器正在执行的所有操作都在等待响应的操作。 async/await 使得调用异步方法的代码不会等待异步方法返回，仅此而已。因此，如果您确实想使用 async/await 来模拟您的第一个模型（我不建议），您可以这样做：

MainMethod()
{
    RunTask1();
    RunTask2();
    RunTask3();
}

async RunTask1()
{
    var one = await Task.Factory.StartNew(()=>TestOutput.DoWork("one"));
    //do stuff with one
}

async RunTask2()
{
    var two= await Task.Factory.StartNew(()=>TestOutput.DoWork("two"));
    //do stuff with two
}

async RunTask3()
{
    var three= await Task.Factory.StartNew(()=>TestOutput.DoWork("three"));
    //do stuff with three
}

代码路径将像这样（如果任务是长时间运行）

1. 对 RunTask1 的主调用
2. RunTask1 等待并返回
3. 对 RunTask2 的主调用
4. RunTask2 等待并返回
5. 对 RunTask3 的主调用
6. RunTask3 等待并返回
7. main 现已完成
8. RunTask1/2/3 返回并继续执行具有 1/2/3 的内容
9. 与 7 相同，但少了已完成的一项
10. 与 7 相同，但少了已完成的 2 个

**** 不过，对此有一个很大的免责声明。如果在点击等待时任务已经完成，则等待将同步运行。这使得运行时不必执行 vudu :)，因为不需要它。这将使上面的代码流不正确，因为该流现在是同步的****

Eric Lippert 的博客文章对此进行了解释事情比我现在做的好多了:)
<一href="http://blogs.msdn.com/b/ericlippert/archive/2010/10/29/asynchronous-programming-in-c-5-0-part-two-whence-await.aspx ">http://blogs.msdn.com/b/ericlippert/archive/2010/10/29/asynchronous-programming-in-c-5-0-part-two-whence-await.aspx

希望这有助于消除您关于异步与 TPL 的一些问题？最重要的是异步不是并行。