这个答案旨在提供一些特定于ASP.NET的信息。

通过在MVC控制器中使用async/await，可以提高线程池的利用率，并实现更好的吞吐量，如下文所述。

http://www.asp.net/mvc/tutorials/mvc-4/using-asynchronous-methods-in-aspnet-mvc-4

在web应用程序中看到大量的并发请求 启动或有突发负载(并发性突然增加)， 使这些web服务调用异步将增加 应用程序的响应性。异步请求采用 处理同步请求所需的时间相同。例如, 如果一个请求进行了web服务调用，需要两秒钟才能完成 完成后，无论执行与否，请求都需要两秒钟 同步或异步。然而，在异步调用期间， 线程在运行时不会阻塞对其他请求的响应 等待第一个请求完成。因此,异步 请求阻止了请求队列和线程池的增长 调用长时间运行的操作的许多并发请求。

回答你的第二个问题-何时使用async -这里有一个相当简单的方法，我们使用:

长时间运行的I/O绑定任务，运行时间超过50ms -使用异步。 长时间运行的cpu绑定任务——使用并行执行、线程等。

解释:当你在做I/O工作时——发送网络请求，从磁盘读取数据等——实际的工作是由“外部”硅(网卡，磁盘控制器等)完成的。一旦工作完成，I/O设备驱动程序将“ping”回操作系统，操作系统将执行你的延续代码，回调等。在此之前，CPU可以自由地做自己的工作(作为奖励，你还可以释放一个线程池线程，这对web应用程序的可伸缩性来说是一个非常好的奖励)

附注:50ms阈值是MS的推荐值。否则，异步所增加的开销(创建状态机、执行上下文等)会消耗掉所有的好处。现在找不到MS的原始文章，但这里也提到了https://www.red-gate.com/simple-talk/dotnet/net-framework/the-overhead-of-asyncawait-in-net-4-5/

这里有一个快速的控制台程序，让那些遵循。TaskToDo方法是你想让它异步的长期运行的方法。让它以异步方式运行是由TestAsync方法完成的。test loops方法只是运行TaskToDo任务，并异步运行它们。你可以在结果中看到这一点，因为它们在每次运行中完成的顺序不同——当它们完成时，它们会报告给控制台UI线程。简单，但我认为简单的例子比复杂的例子更好地揭示了模式的核心:

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

namespace TestingAsync
{
    class Program
    {
        static void Main(string[] args)
        {
            TestLoops();
            Console.Read();
        }

        private static async void TestLoops()
        {
            for (int i = 0; i < 100; i++)
            {
                await TestAsync(i);
            }
        }

        private static Task TestAsync(int i)
        {
            return Task.Run(() => TaskToDo(i));
        }

        private async static void TaskToDo(int i)
        {
            await Task.Delay(10);
            Console.WriteLine(i);
        }
    }
}

这里所有的答案都使用Task.Delay()或其他内置的异步函数。但下面是我的例子，没有使用这些async函数:

// Starts counting to a large number and then immediately displays message "I'm counting...". 
// Then it waits for task to finish and displays "finished, press any key".
static void asyncTest ()
{
    Console.WriteLine("Started asyncTest()");
    Task<long> task = asyncTest_count();
    Console.WriteLine("Started counting, please wait...");
    task.Wait(); // if you comment this line you will see that message "Finished counting" will be displayed before we actually finished counting.
    //Console.WriteLine("Finished counting to " + task.Result.ToString()); // using task.Result seems to also call task.Wait().
    Console.WriteLine("Finished counting.");
    Console.WriteLine("Press any key to exit program.");
    Console.ReadLine();
}

static async Task<long> asyncTest_count()
{
    long k = 0;
    Console.WriteLine("Started asyncTest_count()");
    await Task.Run(() =>
    {
        long countTo = 100000000;
        int prevPercentDone = -1;
        for (long i = 0; i <= countTo; i++)
        {
            int percentDone = (int)(100 * (i / (double)countTo));
            if (percentDone != prevPercentDone)
            {
                prevPercentDone = percentDone;
                Console.Write(percentDone.ToString() + "% ");
            }

            k = i;
        }
    });
    Console.WriteLine("");
    Console.WriteLine("Finished asyncTest_count()");
    return k;
}

也许我的见解是相关的。Async告诉编译器要特别对待一个函数，这个函数是可挂起/可恢复的，它以某种方式保存状态。Await暂停了一个功能，但也是一种执行纪律的方式，是限制性的;你需要指定你在等待什么，你不能无故挂起，这使得代码更有可读性，也许也更有效率。这就引出了另一个问题。为什么不等待多件事，为什么一次只等待一件事?我相信这是因为这样的模式已经建立起来了，而程序员们遵循的是最小惊讶的原则。这里存在着模棱两可的可能性:您是满足其中一个条件，还是希望所有条件都得到满足，也许只是其中一些?

说实话，我仍然认为最好的解释是维基百科上关于未来和承诺的解释:http://en.wikipedia.org/wiki/Futures_and_promises

基本思想是，您拥有一个单独的异步执行任务的线程池。使用时。然而，对象承诺它将在某个时间执行操作，并在您请求时给您结果。这意味着当您请求结果并且还没有完成时，它将阻塞，否则将在线程池中执行。

从那里你可以优化事情:一些操作可以异步实现，你可以优化像文件IO和网络通信通过批处理后续请求和/或重新排序它们。我不确定这是否已经在微软的任务框架中-但如果不是，这将是我首先要添加的事情之一。

实际上，您可以在c# 4.0中实现这种未来模式。如果你想知道它到底是如何工作的，我可以推荐这个链接:http://code.google.com/p/fracture/source/browse/trunk/Squared/TaskLib/。但是，如果您自己开始使用它，您将注意到如果您想做所有很酷的事情，您确实需要语言支持——这正是微软所做的。